TOF/AliTOFtrackerV1.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 // AliTOFtrackerV1 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 #include <TROOT.h>
  31
  32 #include <TClonesArray.h>
  33 #include <TTree.h>
  34 #include <TFile.h>
  35 #include <TH1F.h>
  36 #include <TH2F.h>
  37 #include <TSeqCollection.h>
  38
  39 //#include "AliAlignObj.h"
  40 #include "AliESDtrack.h"
  41 #include "AliESDEvent.h"
  42 #include "AliLog.h"
  43 #include "AliTrackPointArray.h"
  44 #include "AliGeomManager.h"
  45 #include "AliCDBManager.h"
  46
  47 #include "AliTOFcalib.h"
  48 #include "AliTOFRecoParam.h"
  49 #include "AliTOFcluster.h"
  50 #include "AliTOFGeometry.h"
  51 #include "AliTOFtrackerV1.h"
  52 #include "AliTOFtrack.h"
  53 #include "AliTOFpidESD.h"
  54
  55 extern TROOT *gROOT;
  56
  57 ClassImp(AliTOFtrackerV1)
  58
  59 //_____________________________________________________________________________
  60 AliTOFtrackerV1::AliTOFtrackerV1():
  61   fRecoParam(0x0),
  62   fPid(0x0),
  63   fN(0),
  64   fNseeds(0),
  65   fNseedsTOF(0),
  66   fngoodmatch(0),
  67   fnbadmatch(0),
  68   fnunmatch(0),
  69   fnmatch(0),
  70   fTracks(new TClonesArray("AliTOFtrack")),
  71   fSeeds(new TClonesArray("AliESDtrack")),
  72   fHDigClusMap(0x0),
  73   fHDigNClus(0x0),
  74   fHDigClusTime(0x0),
  75   fHDigClusToT(0x0),
  76   fHRecNClus(0x0),
  77   fHRecChi2(0x0),
  78   fHRecDistZ(0x0),
  79   fHRecSigYVsP(0x0),
  80   fHRecSigZVsP(0x0),
  81   fHRecSigYVsPWin(0x0),
  82   fHRecSigZVsPWin(0x0)
  83  {
  84   //AliTOFtrackerV1 main Ctor
  85
  86    // Read the reconstruction parameters from the OCDB
  87    AliTOFcalib *calib = new AliTOFcalib();
  88    fRecoParam = (AliTOFRecoParam*)calib->ReadRecParFromCDB("TOF/Calib",-1);
  89    if(fRecoParam->GetApplyPbPbCuts())fRecoParam=fRecoParam->GetPbPbparam();
  90    Double_t parPID[2];
  91    parPID[0]=fRecoParam->GetTimeResolution();
  92    parPID[1]=fRecoParam->GetTimeNSigma();
  93    fPid=new AliTOFpidESD(parPID);
  94    InitCheckHists();
  95    delete calib;
  96
  97 }
  98 //_____________________________________________________________________________
  99 AliTOFtrackerV1::AliTOFtrackerV1(const AliTOFtrackerV1 &t):
 100   AliTracker(),
 101   fRecoParam(0x0),
 102   fPid(0x0),
 103   fN(0),
 104   fNseeds(0),
 105   fNseedsTOF(0),
 106   fngoodmatch(0),
 107   fnbadmatch(0),
 108   fnunmatch(0),
 109   fnmatch(0),
 110   fTracks(new TClonesArray("AliTOFtrack")),
 111   fSeeds(new TClonesArray("AliESDtrack")),
 112   fHDigClusMap(0x0),
 113   fHDigNClus(0x0),
 114   fHDigClusTime(0x0),
 115   fHDigClusToT(0x0),
 116   fHRecNClus(0x0),
 117   fHRecChi2(0x0),
 118   fHRecDistZ(0x0),
 119   fHRecSigYVsP(0x0),
 120   fHRecSigZVsP(0x0),
 121   fHRecSigYVsPWin(0x0),
 122   fHRecSigZVsPWin(0x0)
 123  {
 124   //AliTOFtrackerV1 copy Ctor
 125
 126   fNseeds=t.fNseeds;
 127   fNseeds=t.fNseeds;
 128   fNseedsTOF=t.fNseedsTOF;
 129   fngoodmatch=t.fngoodmatch;
 130   fnbadmatch=t.fnbadmatch;
 131   fnunmatch=t.fnunmatch;
 132   fnmatch=t.fnmatch;
 133   fRecoParam=t.fRecoParam;
 134   fPid=t.fPid;
 135   fSeeds=t.fSeeds;
 136   fTracks=t.fTracks;
 137   fN=t.fN;
 138 }
 139
 140 //_____________________________________________________________________________
 141 AliTOFtrackerV1& AliTOFtrackerV1::operator=(const AliTOFtrackerV1 &t)
 142 {
 143   //AliTOFtrackerV1 assignment operator
 144
 145   this->fNseeds=t.fNseeds;
 146   this->fNseedsTOF=t.fNseedsTOF;
 147   this->fngoodmatch=t.fngoodmatch;
 148   this->fnbadmatch=t.fnbadmatch;
 149   this->fnunmatch=t.fnunmatch;
 150   this->fnmatch=t.fnmatch;
 151   this->fRecoParam = t.fRecoParam;
 152   this->fPid = t.fPid;
 153   this->fSeeds=t.fSeeds;
 154   this->fTracks=t.fTracks;
 155   this->fN=t.fN;
 156   return *this;
 157
 158 }
 159 //_____________________________________________________________________________
 160 AliTOFtrackerV1::~AliTOFtrackerV1() {
 161   //
 162   // Dtor
 163   //
 164
 165   SaveCheckHists();
 166
 167   if(!(AliCDBManager::Instance()->GetCacheFlag())){
 168     delete fRecoParam;
 169   }
 170   delete fPid;
 171   delete fHDigClusMap;
 172   delete fHDigNClus;
 173   delete fHDigClusTime;
 174   delete fHDigClusToT;
 175   delete fHRecNClus;
 176   delete fHRecChi2;
 177   delete fHRecDistZ;
 178   delete fHRecSigYVsP;
 179   delete fHRecSigZVsP;
 180   delete fHRecSigYVsPWin;
 181   delete fHRecSigZVsPWin;
 182   if (fTracks){
 183     fTracks->Delete();
 184     delete fTracks;
 185     fTracks=0x0;
 186   }
 187   if (fSeeds){
 188     fSeeds->Delete();
 189     delete fSeeds;
 190     fSeeds=0x0;
 191   }
 192 }
 193 //_____________________________________________________________________________
 194 Int_t AliTOFtrackerV1::PropagateBack(AliESDEvent* event) {
 195   //
 196   // Gets seeds from ESD event and Match with TOF Clusters
 197   //
 198
 199
 200   //Initialise some counters
 201
 202   fNseeds=0;
 203   fNseedsTOF=0;
 204   fngoodmatch=0;
 205   fnbadmatch=0;
 206   fnunmatch=0;
 207   fnmatch=0;
 208
 209   Int_t ntrk=event->GetNumberOfTracks();
 210   fNseeds = ntrk;
 211   TClonesArray &aESDTrack = *fSeeds;
 212
 213
 214   //Load ESD tracks into a local Array of ESD Seeds
 215
 216   for (Int_t i=0; i<fNseeds; i++) {
 217     AliESDtrack *t=event->GetTrack(i);
 218     new(aESDTrack[i]) AliESDtrack(*t);
 219   }
 220
 221   //Prepare ESD tracks candidates for TOF Matching
 222   CollectESD();
 223
 224   //Matching Step
 225   MatchTracks();
 226
 227   AliInfo(Form("Number of matched tracks: %d",fnmatch));
 228   AliInfo(Form("Number of good matched tracks: %d",fngoodmatch));
 229   AliInfo(Form("Number of bad  matched tracks: %d",fnbadmatch));
 230
 231   //Update the matched ESD tracks
 232
 233   for (Int_t i=0; i<ntrk; i++) {
 234     AliESDtrack *t=event->GetTrack(i);
 235     AliESDtrack *seed =(AliESDtrack*)fSeeds->UncheckedAt(i);
 236     if(seed->GetTOFsignal()>0){
 237       t->SetTOFsignal(seed->GetTOFsignal());
 238       t->SetTOFcluster(seed->GetTOFcluster());
 239       t->SetTOFsignalToT(seed->GetTOFsignalToT());
 240       t->SetTOFsignalRaw(seed->GetTOFsignalRaw());
 241       t->SetTOFsignalDz(seed->GetTOFsignalDz());
 242       t->SetTOFCalChannel(seed->GetTOFCalChannel());
 243       Int_t tlab[3]; seed->GetTOFLabel(tlab);
 244       t->SetTOFLabel(tlab);
 245       AliTOFtrack *track = new AliTOFtrack(*seed);
 246       t->UpdateTrackParams(track,AliESDtrack::kTOFout);
 247       delete track;
 248     }
 249   }
 250
 251   //Handle Time Zero information
 252
 253   Double_t timeZero=0.;
 254   Double_t timeZeroMax=99999.;
 255   Bool_t usetimeZero     = fRecoParam->UseTimeZero();
 256   Bool_t timeZeroFromT0  = fRecoParam->GetTimeZerofromT0();
 257   Bool_t timeZeroFromTOF = fRecoParam->GetTimeZerofromTOF();
 258
 259   AliDebug(1,Form("Use Time Zero?: %d",usetimeZero));
 260   AliDebug(1,Form("Time Zero from T0? : %d",timeZeroFromT0));
 261   AliDebug(1,Form("Time Zero From TOF? : %d",timeZeroFromTOF));
 262
 263   if(usetimeZero){
 264     if(timeZeroFromT0){
 265       timeZero=GetTimeZerofromT0(event);
 266     }
 267     if(timeZeroFromTOF && (timeZero>timeZeroMax || !timeZeroFromT0)){
 268       timeZero=GetTimeZerofromTOF(event);
 269     }
 270   }
 271   AliDebug(2,Form("time Zero used in PID: %f",timeZero));
 272   //Make TOF PID
 273   fPid->MakePID(event,timeZero);
 274
 275   fSeeds->Clear();
 276   fTracks->Clear();
 277   return 0;
 278
 279 }
 280 //_________________________________________________________________________
 281 void AliTOFtrackerV1::CollectESD() {
 282    //prepare the set of ESD tracks to be matched to clusters in TOF
 283
 284   Int_t seedsTOF1=0;
 285   Int_t seedsTOF2=0;
 286
 287   TClonesArray &aTOFTrack = *fTracks;
 288   for (Int_t i=0; i<fNseeds; i++) {
 289
 290     AliESDtrack *t =(AliESDtrack*)fSeeds->UncheckedAt(i);
 291     if ((t->GetStatus()&AliESDtrack::kTPCout)==0)continue;
 292
 293     // TRD 'good' tracks, already propagated at 372 cm
 294
 295     AliTOFtrack *track = new AliTOFtrack(*t); // New
 296     Double_t x = track->GetX(); //New
 297
 298     if (((t->GetStatus()&AliESDtrack::kTRDout)!=0 ) &&
 299          ( x >= AliTOFGeometry::RinTOF()) ){
 300       track->SetSeedIndex(i);
 301       t->UpdateTrackParams(track,AliESDtrack::kTOFout);
 302       new(aTOFTrack[fNseedsTOF]) AliTOFtrack(*track);
 303       fNseedsTOF++;
 304       seedsTOF1++;
 305       delete track;
 306     }
 307
 308     // Propagate the rest of TPCbp
 309
 310     else {
 311       if(track->PropagateToInnerTOF()){
 312         track->SetSeedIndex(i);
 313         t->UpdateTrackParams(track,AliESDtrack::kTOFout);
 314         new(aTOFTrack[fNseedsTOF]) AliTOFtrack(*track);
 315         fNseedsTOF++;
 316         seedsTOF2++;
 317       }
 318       delete track;
 319     }
 320   }
 321
 322   AliInfo(Form("Number of TOF seeds %i",fNseedsTOF));
 323   AliInfo(Form("Number of TOF seeds Type 1 %i",seedsTOF1));
 324   AliInfo(Form("Number of TOF seeds Type 2 %i",seedsTOF2));
 325
 326   // Sort according uncertainties on track position
 327   fTracks->Sort();
 328
 329 }
 330 //_________________________________________________________________________
 331 void AliTOFtrackerV1::MatchTracks( ){
 332   //
 333   //Match ESD tracks to clusters in TOF
 334   //
 335
 336
 337   // Parameters regulating the reconstruction
 338   Float_t dY=AliTOFGeometry::XPad();
 339   Float_t dZ=AliTOFGeometry::ZPad();
 340
 341   const Int_t kncmax = 100;
 342   Float_t sensRadius = fRecoParam->GetSensRadius();
 343   Float_t scaleFact   = fRecoParam->GetWindowScaleFact();
 344   Float_t dyMax=fRecoParam->GetWindowSizeMaxY();
 345   Float_t dzMax=fRecoParam->GetWindowSizeMaxZ();
 346   Double_t maxChi2=fRecoParam->GetMaxChi2();
 347   Bool_t timeWalkCorr    = fRecoParam->GetTimeWalkCorr();
 348   AliDebug(1,"++++++++++++++TOF Reconstruction Parameters:++++++++++++ \n");
 349   AliDebug(1,Form("TOF sens radius: %f",sensRadius));
 350   AliDebug(1,Form("TOF Window scale factor: %f",scaleFact));
 351   AliDebug(1,Form("TOF Window max dy: %f",dyMax));
 352   AliDebug(1,Form("TOF Window max dz: %f",dzMax));
 353   AliDebug(1,Form("TOF Max Chi2: %f",maxChi2));
 354   AliDebug(1,Form("Time Walk Correction? : %d",timeWalkCorr));
 355
 356
 357   //The matching loop
 358
 359   for (Int_t iseed=0; iseed<fNseedsTOF; iseed++) {
 360
 361     AliTOFtrack *track =(AliTOFtrack*)fTracks->UncheckedAt(iseed);
 362     AliESDtrack *t =(AliESDtrack*)fSeeds->UncheckedAt(track->GetSeedIndex());
 363     if(t->GetTOFsignal()>0. ) continue;
 364     AliTOFtrack *trackTOFin =new AliTOFtrack(*track);
 365
 366     // Determine a window around the track
 367     Double_t x,par[5]; trackTOFin->GetExternalParameters(x,par);
 368     Double_t cov[15]; trackTOFin->GetExternalCovariance(cov);
 369
 370     Double_t z    = par[1];
 371     Double_t dz   =  scaleFact*3.*TMath::Sqrt(cov[2]+dZ*dZ/12);
 372     Double_t dphi =  scaleFact*3.*TMath::Sqrt(cov[0]+dY*dY/12.)/sensRadius;
 373
 374     Double_t phi=TMath::ATan2(par[0],x) + trackTOFin->GetAlpha();
 375     if (phi<-TMath::Pi())phi+=2*TMath::Pi();
 376     if (phi>=TMath::Pi())phi-=2*TMath::Pi();
 377
 378     //upper limit on window's size.
 379     if(dz> dzMax) dz=dzMax;
 380     if(dphi*sensRadius> dyMax) dphi=dyMax/sensRadius;
 381
 382
 383     // find the clusters inside the selected window
 384     Int_t nc=0;
 385     AliTOFcluster *clusters[kncmax]; // pointers to the clusters in the window
 386     Int_t index[kncmax];//to keep track of the cluster index
 387     for (Int_t k=FindClusterIndex(z-dz); k<fN; k++) {
 388       AliTOFcluster *c=fClusters[k];
 389       if(nc>kncmax)break;
 390       if(c->GetZ() > z+dz) break;
 391       if(c->IsUsed()) continue;
 392       if(!c->GetStatus()) continue; // skip bad channels as declared in OCDB
 393       Float_t xyz[3]; c->GetGlobalXYZ(xyz);
 394       Double_t clPhi=TMath::ATan2(xyz[1],xyz[0]);
 395       Double_t dph=TMath::Abs(clPhi-phi);
 396       if (dph>TMath::Pi()) dph-=2.*TMath::Pi();
 397       if (TMath::Abs(dph)>dphi) continue;
 398       clusters[nc]=c;
 399       index[nc] = k;
 400       nc++;
 401     }
 402
 403     //start propagation: go to the average TOF pad middle plane at ~379.5 cm
 404
 405     Float_t  xTOF = sensRadius;
 406     Double_t ymax = xTOF*TMath::Tan(0.5*AliTOFGeometry::GetAlpha());
 407     Bool_t skip = kFALSE;
 408     Double_t ysect = trackTOFin->GetYat(xTOF,skip);
 409     if (skip) break;
 410     if (ysect > ymax) {
 411       if (!trackTOFin->Rotate(AliTOFGeometry::GetAlpha())) {
 412         break;
 413       }
 414     } else if (ysect <-ymax) {
 415       if (!trackTOFin->Rotate(AliTOFGeometry::GetAlpha())) {
 416         break;
 417       }
 418     }
 419     if(!trackTOFin->PropagateTo(xTOF)) {
 420       break;
 421     }
 422
 423
 424     AliTOFcluster *bestCluster=0;
 425     Double_t bestChi2=maxChi2;
 426     Int_t idclus=-1;
 427     for (Int_t i=0; i<nc; i++){
 428       AliTOFcluster *c=clusters[i];  // one of the preselected clusters
 429       Double_t chi2=trackTOFin->GetPredictedChi2((AliCluster3D*)c);
 430       if (chi2 >= bestChi2) continue;
 431       bestChi2=chi2;
 432       bestCluster=c;
 433       idclus=index[i];
 434     }
 435
 436     if (!bestCluster) {  // no matching , go to the next track
 437       fnunmatch++;
 438       delete trackTOFin;
 439       continue;
 440     }
 441
 442     fnmatch++;
 443     bestCluster->Use();
 444     if (
 445         (bestCluster->GetLabel(0)==TMath::Abs(trackTOFin->GetLabel()))
 446         ||
 447         (bestCluster->GetLabel(1)==TMath::Abs(trackTOFin->GetLabel()))
 448         ||
 449         (bestCluster->GetLabel(2)==TMath::Abs(trackTOFin->GetLabel()))
 450         ) {
 451       fngoodmatch++;
 452        AliDebug(2,Form(" track label good %5i",trackTOFin->GetLabel()));
 453
 454     }
 455     else{
 456       fnbadmatch++;
 457       AliDebug(2,Form(" track label bad %5i",trackTOFin->GetLabel()));
 458     }
 459
 460     //Propagate the track to the best matched cluster
 461     trackTOFin->PropagateTo(bestCluster);
 462
 463
 464     //now take the local distance in Z from the pad center for time walk correction
 465     Float_t tiltangle = AliTOFGeometry::GetAngles(bestCluster->GetDetInd(1),bestCluster->GetDetInd(2))*TMath::DegToRad();
 466     Double_t dzTW=trackTOFin->GetZ()-bestCluster->GetZ(); // in cm
 467     dzTW/=TMath::Cos(tiltangle);
 468
 469     //update the ESD track and delete the TOFtrack
 470     t->UpdateTrackParams(trackTOFin,AliESDtrack::kTOFout);
 471     delete trackTOFin;
 472
 473     //  Store quantities to be used in the TOF Calibration
 474     Float_t tToT=AliTOFGeometry::ToTBinWidth()*bestCluster->GetToT()*1E-3; // in ns
 475     t->SetTOFsignalToT(tToT);
 476     Float_t rawTime=AliTOFGeometry::TdcBinWidth()*bestCluster->GetTDCRAW()+32; // RAW time,in ps
 477     t->SetTOFsignalRaw(rawTime);
 478     t->SetTOFsignalDz(dzTW);
 479     AliDebug(2,Form(" Setting TOF raw time: %f  z distance: %f time: %f = ",rawTime,dzTW));
 480     Int_t ind[5];
 481     ind[0]=bestCluster->GetDetInd(0);
 482     ind[1]=bestCluster->GetDetInd(1);
 483     ind[2]=bestCluster->GetDetInd(2);
 484     ind[3]=bestCluster->GetDetInd(3);
 485     ind[4]=bestCluster->GetDetInd(4);
 486     Int_t calindex = AliTOFGeometry::GetIndex(ind);
 487     t->SetTOFCalChannel(calindex);
 488
 489     // keep track of the track labels in the matched cluster
 490     Int_t tlab[3];
 491     tlab[0]=bestCluster->GetLabel(0);
 492     tlab[1]=bestCluster->GetLabel(1);
 493     tlab[2]=bestCluster->GetLabel(2);
 494     AliDebug(2,Form(" tdc time of the matched track %i = ",bestCluster->GetTDC()));
 495     Double_t tof=AliTOFGeometry::TdcBinWidth()*bestCluster->GetTDC()+32; // in ps
 496     AliDebug(2,Form(" tof time of the matched track: %f = ",tof));
 497     Double_t tofcorr=tof;
 498     if(timeWalkCorr)tofcorr=CorrectTimeWalk(dzTW,tof);
 499     AliDebug(2,Form(" tof time of the matched track, after TW corr: %f = ",tofcorr));
 500     //Set TOF time signal and pointer to the matched cluster
 501     t->SetTOFsignal(tofcorr);
 502     t->SetTOFcluster(idclus); // pointing to the recPoints tree
 503     t->SetTOFLabel(tlab);
 504
 505     Double_t mom=t->GetP();
 506     // Fill Reco-QA histos for Reconstruction
 507     fHRecNClus->Fill(nc);
 508     fHRecChi2->Fill(bestChi2);
 509     fHRecDistZ->Fill(dzTW);
 510     fHRecSigYVsP->Fill(mom,TMath::Sqrt(cov[0]));
 511     fHRecSigZVsP->Fill(mom,TMath::Sqrt(cov[2]));
 512     fHRecSigYVsPWin->Fill(mom,dphi*sensRadius);
 513     fHRecSigZVsPWin->Fill(mom,dz);
 514
 515     // Fill Tree for on-the-fly offline Calibration
 516     // no longer there - all info is in the ESDs now
 517
 518   }
 519
 520 }
 521 //_________________________________________________________________________
 522 Int_t AliTOFtrackerV1::LoadClusters(TTree *cTree) {
 523   //--------------------------------------------------------------------
 524   //This function loads the TOF clusters
 525   //--------------------------------------------------------------------
 526
 527   Int_t npadX = AliTOFGeometry::NpadX();
 528   Int_t npadZ = AliTOFGeometry::NpadZ();
 529   Int_t nStripA = AliTOFGeometry::NStripA();
 530   Int_t nStripB = AliTOFGeometry::NStripB();
 531   Int_t nStripC = AliTOFGeometry::NStripC();
 532
 533   TBranch *branch=cTree->GetBranch("TOF");
 534   if (!branch) {
 535     AliError("can't get the branch with the TOF clusters !");
 536     return 1;
 537   }
 538
 539   static TClonesArray dummy("AliTOFcluster",10000);
 540   dummy.Clear();
 541   TClonesArray *clusters=&dummy;
 542   branch->SetAddress(&clusters);
 543
 544   cTree->GetEvent(0);
 545   Int_t nc=clusters->GetEntriesFast();
 546   fHDigNClus->Fill(nc);
 547
 548   AliInfo(Form("Number of clusters: %d",nc));
 549
 550   for (Int_t i=0; i<nc; i++) {
 551     AliTOFcluster *c=(AliTOFcluster*)clusters->UncheckedAt(i);
 552     fClusters[i]=new AliTOFcluster(*c); fN++;
 553
 554   // Fill Digits QA histos
 555
 556     Int_t isector = c->GetDetInd(0);
 557     Int_t iplate = c->GetDetInd(1);
 558     Int_t istrip = c->GetDetInd(2);
 559     Int_t ipadX = c->GetDetInd(4);
 560     Int_t ipadZ = c->GetDetInd(3);
 561
 562     Float_t time =(AliTOFGeometry::TdcBinWidth()*c->GetTDC())*1E-3; // in ns
 563     Float_t tot = (AliTOFGeometry::TdcBinWidth()*c->GetToT())*1E-3;//in ns
 564
 565     Int_t stripOffset = 0;
 566     switch (iplate) {
 567     case 0:
 568       stripOffset = 0;
 569       break;
 570     case 1:
 571       stripOffset = nStripC;
 572       break;
 573     case 2:
 574       stripOffset = nStripC+nStripB;
 575       break;
 576     case 3:
 577       stripOffset = nStripC+nStripB+nStripA;
 578       break;
 579     case 4:
 580       stripOffset = nStripC+nStripB+nStripA+nStripB;
 581       break;
 582     default:
 583       AliError(Form("Wrong plate number in TOF (%d) !",iplate));
 584       break;
 585     };
 586     Int_t zindex=npadZ*(istrip+stripOffset)+(ipadZ+1);
 587     Int_t phiindex=npadX*isector+ipadX+1;
 588     fHDigClusMap->Fill(zindex,phiindex);
 589     fHDigClusTime->Fill(time);
 590     fHDigClusToT->Fill(tot);
 591   }
 592
 593
 594   return 0;
 595 }
 596 //_________________________________________________________________________
 597 void AliTOFtrackerV1::UnloadClusters() {
 598   //--------------------------------------------------------------------
 599   //This function unloads TOF clusters
 600   //--------------------------------------------------------------------
 601   for (Int_t i=0; i<fN; i++) {
 602     delete fClusters[i];
 603     fClusters[i] = 0x0;
 604   }
 605   fN=0;
 606 }
 607
 608 //_________________________________________________________________________
 609 Int_t AliTOFtrackerV1::FindClusterIndex(Double_t z) const {
 610   //--------------------------------------------------------------------
 611   // This function returns the index of the nearest cluster
 612   //--------------------------------------------------------------------
 613   //MOD
 614   //Here we need to get the Z in the tracking system
 615
 616   if (fN==0) return 0;
 617   if (z <= fClusters[0]->GetZ()) return 0;
 618   if (z > fClusters[fN-1]->GetZ()) return fN;
 619   Int_t b=0, e=fN-1, m=(b+e)/2;
 620   for (; b<e; m=(b+e)/2) {
 621     if (z > fClusters[m]->GetZ()) b=m+1;
 622     else e=m;
 623   }
 624   return m;
 625 }
 626
 627 //_________________________________________________________________________
 628 Bool_t AliTOFtrackerV1::GetTrackPoint(Int_t index, AliTrackPoint& p) const
 629 {
 630   // Get track space point with index i
 631   // Coordinates are in the global system
 632   AliTOFcluster *cl = fClusters[index];
 633   Float_t xyz[3];
 634   cl->GetGlobalXYZ(xyz);
 635   Float_t phi=TMath::ATan2(xyz[1],xyz[0]);
 636   Float_t phiangle = (Int_t(phi*TMath::RadToDeg()/20.)+0.5)*20.*TMath::DegToRad();
 637   Float_t sinphi = TMath::Sin(phiangle), cosphi = TMath::Cos(phiangle);
 638   Float_t tiltangle = AliTOFGeometry::GetAngles(cl->GetDetInd(1),cl->GetDetInd(2))*TMath::DegToRad();
 639   Float_t sinth = TMath::Sin(tiltangle), costh = TMath::Cos(tiltangle);
 640   Float_t sigmay2 = AliTOFGeometry::XPad()*AliTOFGeometry::XPad()/12.;
 641   Float_t sigmaz2 = AliTOFGeometry::ZPad()*AliTOFGeometry::ZPad()/12.;
 642   Float_t cov[6];
 643   cov[0] = sinphi*sinphi*sigmay2 + cosphi*cosphi*sinth*sinth*sigmaz2;
 644   cov[1] = -sinphi*cosphi*sigmay2 + sinphi*cosphi*sinth*sinth*sigmaz2;
 645   cov[2] = -cosphi*sinth*costh*sigmaz2;
 646   cov[3] = cosphi*cosphi*sigmay2 + sinphi*sinphi*sinth*sinth*sigmaz2;
 647   cov[4] = -sinphi*sinth*costh*sigmaz2;
 648   cov[5] = costh*costh*sigmaz2;
 649   p.SetXYZ(xyz[0],xyz[1],xyz[2],cov);
 650
 651   // Detector numbering scheme
 652   Int_t nSector = AliTOFGeometry::NSectors();
 653   Int_t nPlate  = AliTOFGeometry::NPlates();
 654   Int_t nStripA = AliTOFGeometry::NStripA();
 655   Int_t nStripB = AliTOFGeometry::NStripB();
 656   Int_t nStripC = AliTOFGeometry::NStripC();
 657
 658   Int_t isector = cl->GetDetInd(0);
 659   if (isector >= nSector)
 660     AliError(Form("Wrong sector number in TOF (%d) !",isector));
 661   Int_t iplate = cl->GetDetInd(1);
 662   if (iplate >= nPlate)
 663     AliError(Form("Wrong plate number in TOF (%d) !",iplate));
 664   Int_t istrip = cl->GetDetInd(2);
 665
 666   Int_t stripOffset = 0;
 667   switch (iplate) {
 668   case 0:
 669     stripOffset = 0;
 670     break;
 671   case 1:
 672     stripOffset = nStripC;
 673     break;
 674   case 2:
 675     stripOffset = nStripC+nStripB;
 676     break;
 677   case 3:
 678     stripOffset = nStripC+nStripB+nStripA;
 679     break;
 680   case 4:
 681     stripOffset = nStripC+nStripB+nStripA+nStripB;
 682     break;
 683   default:
 684     AliError(Form("Wrong plate number in TOF (%d) !",iplate));
 685     break;
 686   };
 687
 688   Int_t idet = (2*(nStripC+nStripB)+nStripA)*isector +
 689                stripOffset +
 690                istrip;
 691   UShort_t volid = AliGeomManager::LayerToVolUID(AliGeomManager::kTOF,idet);
 692   p.SetVolumeID((UShort_t)volid);
 693   return kTRUE;
 694 }
 695 //_________________________________________________________________________
 696 void AliTOFtrackerV1::InitCheckHists() {
 697
 698   //Init histos for Digits/Reco QA and Calibration
 699
 700   //Digits "QA"
 701   fHDigClusMap = new TH2F("TOFDig_ClusMap", "",182,0.5,182.5,864, 0.5,864.5);
 702   fHDigNClus = new TH1F("TOFDig_NClus", "",200,0.5,200.5);
 703   fHDigClusTime = new TH1F("TOFDig_ClusTime", "",2000,0.,200.);
 704   fHDigClusToT = new TH1F("TOFDig_ClusToT", "",500,0.,100);
 705
 706   //Reco "QA"
 707   fHRecNClus =new TH1F("TOFRec_NClusW", "",50,0.5,50.5);
 708   fHRecDistZ=new TH1F("TOFRec_DistZ", "",50,0.5,10.5);
 709   fHRecChi2=new TH1F("TOFRec_Chi2", "",100,0.,10.);
 710   fHRecSigYVsP=new TH2F("TOFDig_SigYVsP", "",40,0.,4.,100, 0.,5.);
 711   fHRecSigZVsP=new TH2F("TOFDig_SigZVsP", "",40,0.,4.,100, 0.,5.);
 712   fHRecSigYVsPWin=new TH2F("TOFDig_SigYVsPWin", "",40,0.,4.,100, 0.,50.);
 713   fHRecSigZVsPWin=new TH2F("TOFDig_SigZVsPWin", "",40,0.,4.,100, 0.,50.);
 714 }
 715
 716 //_________________________________________________________________________
 717 void AliTOFtrackerV1::SaveCheckHists() {
 718
 719   //write histos for Digits/Reco QA and Calibration
 720
 721   TDirectory *dir = gDirectory;
 722   TFile *logFile = 0;
 723   TFile *logFileTOF = 0;
 724
 725   TSeqCollection *list = gROOT->GetListOfFiles();
 726   int n = list->GetEntries();
 727   for(int i=0; i<n; i++) {
 728     logFile = (TFile*)list->At(i);
 729     if (strstr(logFile->GetName(), "AliESDs.root")) break;
 730   }
 731
 732   Bool_t isThere=kFALSE;
 733   for(int i=0; i<n; i++) {
 734     logFileTOF = (TFile*)list->At(i);
 735     if (strstr(logFileTOF->GetName(), "TOFQA.root")){
 736       isThere=kTRUE;
 737       break;
 738     }
 739   }
 740
 741   logFile->cd();
 742   fHDigClusMap->Write(fHDigClusMap->GetName(), TObject::kOverwrite);
 743   fHDigNClus->Write(fHDigNClus->GetName(), TObject::kOverwrite);
 744   fHDigClusTime->Write(fHDigClusTime->GetName(), TObject::kOverwrite);
 745   fHDigClusToT->Write(fHDigClusToT->GetName(), TObject::kOverwrite);
 746   fHRecNClus->Write(fHRecNClus->GetName(), TObject::kOverwrite);
 747   fHRecChi2->Write(fHRecChi2->GetName(), TObject::kOverwrite);
 748   fHRecDistZ->Write(fHRecDistZ->GetName(), TObject::kOverwrite);
 749   fHRecSigYVsP->Write(fHRecSigYVsP->GetName(), TObject::kOverwrite);
 750   fHRecSigZVsP->Write(fHRecSigZVsP->GetName(), TObject::kOverwrite);
 751   fHRecSigYVsPWin->Write(fHRecSigYVsPWin->GetName(), TObject::kOverwrite);
 752   fHRecSigZVsPWin->Write(fHRecSigZVsPWin->GetName(), TObject::kOverwrite);
 753   logFile->Flush();
 754
 755   if(!isThere)logFileTOF = new TFile( "TOFQA.root","RECREATE");
 756   logFileTOF->cd();
 757   fHDigClusMap->Write(fHDigClusMap->GetName(), TObject::kOverwrite);
 758   fHDigNClus->Write(fHDigNClus->GetName(), TObject::kOverwrite);
 759   fHDigClusTime->Write(fHDigClusTime->GetName(), TObject::kOverwrite);
 760   fHDigClusToT->Write(fHDigClusToT->GetName(), TObject::kOverwrite);
 761   fHRecNClus->Write(fHRecNClus->GetName(), TObject::kOverwrite);
 762   fHRecChi2->Write(fHRecChi2->GetName(), TObject::kOverwrite);
 763   fHRecDistZ->Write(fHRecDistZ->GetName(), TObject::kOverwrite);
 764   fHRecSigYVsP->Write(fHRecSigYVsP->GetName(), TObject::kOverwrite);
 765   fHRecSigZVsP->Write(fHRecSigZVsP->GetName(), TObject::kOverwrite);
 766   fHRecSigYVsPWin->Write(fHRecSigYVsPWin->GetName(), TObject::kOverwrite);
 767   fHRecSigZVsPWin->Write(fHRecSigZVsPWin->GetName(), TObject::kOverwrite);
 768   logFileTOF->Flush();
 769
 770   dir->cd();
 771   }
 772 //_________________________________________________________________________
 773 Float_t AliTOFtrackerV1::CorrectTimeWalk( Float_t dist, Float_t tof) {
 774
 775   //dummy, for the moment
 776   Float_t tofcorr=0.;
 777   if(dist<AliTOFGeometry::ZPad()*0.5){
 778     tofcorr=tof;
 779     //place here the actual correction
 780   }else{
 781     tofcorr=tof;
 782   }
 783   return tofcorr;
 784 }
 785 //_________________________________________________________________________
 786 Float_t AliTOFtrackerV1::GetTimeZerofromT0(AliESDEvent *event) const {
 787
 788   //Returns TimeZero as measured by T0 detector
 789
 790   return event->GetT0();
 791 }
 792 //_________________________________________________________________________
 793 Float_t AliTOFtrackerV1::GetTimeZerofromTOF(AliESDEvent * /*event*/) const {
 794
 795   //dummy, for the moment. T0 algorithm using tracks on TOF
 796   {
 797     //place T0 algo here...
 798   }
 799   return 0.;
 800 }