TOF/AliTOFClusterFinder.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 Revision 0.03  2005/07/28 A. De Caro
  19          Implement public method
  20          Raw2Digits(Int_t, AliRawReader *)
  21          to convert digits from raw data in MC digits
  22          (temporary solution)
  23
  24 Revision 0.02  2005/07/27 A. De Caro
  25          Implement public method
  26          Digits2RecPoint(Int_t)
  27          to convert digits in clusters
  28
  29 Revision 0.02  2005/07/26 A. De Caro
  30          Implement private methods
  31          InsertCluster(AliTOFcluster *)
  32          FindClusterIndex(Double_t)
  33          originally implemented in AliTOFtracker
  34          by S. Arcelli and C. Zampolli
  35
  36 Revision 0.01  2005/07/25 A. De Caro
  37          Implement public methods
  38          Digits2RecPoint(AliRawReader *, TTree *)
  39          Digits2RecPoint(Int_t, AliRawReader *)
  40          to convert raw data in clusters
  41  */
  42
  43 ////////////////////////////////////////////////////////////////
  44 //                                                            //
  45 //         Class for TOF cluster finder                       //
  46 //                                                            //
  47 // Starting from Raw Data, create rec points,                 //
  48 //                         fill TreeR for TOF,                //
  49 //                         write TOF.RecPoints.root file      //
  50 //                                                            //
  51 ////////////////////////////////////////////////////////////////
  52
  53 #include "TClonesArray.h"
  54 #include "TFile.h"
  55 #include "TTree.h"
  56
  57 #include "AliLoader.h"
  58 #include "AliLog.h"
  59 #include "AliRawReader.h"
  60 #include "AliRunLoader.h"
  61
  62 #include "AliTOFcalib.h"
  63 #include "AliTOFCal.h"
  64 #include "AliTOFChannel.h"
  65 #include "AliTOFClusterFinder.h"
  66 #include "AliTOFcluster.h"
  67 #include "AliTOFdigit.h"
  68 #include "AliTOFGeometryV5.h"
  69 #include "AliTOFGeometry.h"
  70 #include "AliTOFRawStream.h"
  71
  72 extern TFile *gFile;
  73
  74 ClassImp(AliTOFClusterFinder)
  75
  76 AliTOFClusterFinder::AliTOFClusterFinder():
  77   fRunLoader(0),
  78   fTOFLoader(0),
  79   fTreeD(0),
  80   fTreeR(0),
  81   fDigits(new TClonesArray("AliTOFdigit", 4000)),
  82   fRecPoints(new TClonesArray("AliTOFcluster", 4000)),
  83   fNumberOfTofClusters(0)
  84 {
  85 //
  86 // Constructor
  87 //
  88
  89   fTOFGeometry = new AliTOFGeometryV5();
  90   AliInfo("V5 TOF Geometry is taken as the default");
  91
  92 }
  93 //______________________________________________________________________________
  94
  95 AliTOFClusterFinder::AliTOFClusterFinder(AliRunLoader* runLoader):
  96   fRunLoader(runLoader),
  97   fTOFLoader(runLoader->GetLoader("TOFLoader")),
  98   fTreeD(0),
  99   fTreeR(0),
 100   fDigits(new TClonesArray("AliTOFdigit", 4000)),
 101   fRecPoints(new TClonesArray("AliTOFcluster", 4000)),
 102   fNumberOfTofClusters(0)
 103 {
 104 //
 105 // Constructor
 106 //
 107
 108   runLoader->CdGAFile();
 109   TFile *in=(TFile*)gFile;
 110   in->cd();
 111   fTOFGeometry = (AliTOFGeometry*)in->Get("TOFgeometry");
 112
 113 }
 114
 115 //------------------------------------------------------------------------
 116 AliTOFClusterFinder::AliTOFClusterFinder(const AliTOFClusterFinder &source)
 117   :TObject()
 118 {
 119   // copy constructor
 120   this->fDigits=source.fDigits;
 121   this->fRecPoints=source.fRecPoints;
 122   this->fTOFGeometry=source.fTOFGeometry;
 123
 124 }
 125
 126 //------------------------------------------------------------------------
 127   AliTOFClusterFinder& AliTOFClusterFinder::operator=(const AliTOFClusterFinder &source)
 128 {
 129   // ass. op.
 130   this->fDigits=source.fDigits;
 131   this->fRecPoints=source.fRecPoints;
 132   this->fTOFGeometry=source.fTOFGeometry;
 133   return *this;
 134
 135 }
 136 //______________________________________________________________________________
 137
 138 AliTOFClusterFinder::~AliTOFClusterFinder()
 139 {
 140
 141   //
 142   // Destructor
 143   //
 144
 145   if (fDigits)
 146     {
 147       fDigits->Delete();
 148       delete fDigits;
 149       fDigits=0;
 150     }
 151   if (fRecPoints)
 152     {
 153       fRecPoints->Delete();
 154       delete fRecPoints;
 155       fRecPoints=0;
 156     }
 157
 158   delete fTOFGeometry;
 159
 160 }
 161 //______________________________________________________________________________
 162
 163 void AliTOFClusterFinder::Digits2RecPoints(Int_t iEvent)
 164 {
 165   //
 166   // Converts digits to recpoints for TOF
 167   //
 168
 169   fRunLoader->GetEvent(iEvent);
 170
 171   fTreeD = fTOFLoader->TreeD();
 172   if (fTreeD == 0x0)
 173     {
 174       AliFatal("AliTOFClusterFinder: Can not get TreeD");
 175     }
 176
 177   TBranch *branch = fTreeD->GetBranch("TOF");
 178   if (!branch) {
 179     AliError("can't get the branch with the TOF digits !");
 180     return;
 181   }
 182
 183   TClonesArray dummy("AliTOFdigit",10000), *digits=&dummy;
 184   branch->SetAddress(&digits);
 185
 186   ResetRecpoint();
 187
 188   fTreeR = fTOFLoader->TreeR();
 189   if (fTreeR == 0x0)
 190     {
 191       fTOFLoader->MakeTree("R");
 192       fTreeR = fTOFLoader->TreeR();
 193     }
 194
 195   Int_t bufsize = 32000;
 196   fTreeR->Branch("TOF", &fRecPoints, bufsize);
 197
 198   fTreeD->GetEvent(0);
 199   Int_t nDigits = digits->GetEntriesFast();
 200   AliDebug(2,Form("Number of TOF digits: %d",nDigits));
 201
 202   Int_t ii, jj;
 203   Int_t dig[5];
 204   Float_t g[3];
 205   Double_t h[5];
 206   Float_t tToT;
 207   Double_t tTdcND;
 208   for (ii=0; ii<nDigits; ii++) {
 209     AliTOFdigit *d = (AliTOFdigit*)digits->UncheckedAt(ii);
 210     dig[0]=d->GetSector();
 211     dig[1]=d->GetPlate();
 212     dig[2]=d->GetStrip();
 213     dig[3]=d->GetPadz();
 214     dig[4]=d->GetPadx();
 215
 216     for (jj=0; jj<3; jj++) g[jj] = 0.;
 217     fTOFGeometry->GetPos(dig,g);
 218
 219     h[0] = TMath::Sqrt(g[0]*g[0]+g[1]*g[1]);
 220     h[1] = TMath::ATan2(g[1],g[0]);
 221     h[2] = g[2];
 222     h[3] = d->GetTdc();
 223     h[4] = d->GetAdc();
 224     tToT = d->GetToT();
 225     tTdcND = d->GetTdcND();
 226
 227     AliTOFcluster *tofCluster = new AliTOFcluster(h,d->GetTracks(),dig,ii,tToT, tTdcND);
 228     InsertCluster(tofCluster);
 229
 230   }
 231
 232   AliInfo(Form("Number of found clusters: %i", fNumberOfTofClusters));
 233
 234   CalibrateRecPoint();
 235   FillRecPoint();
 236
 237   fTreeR->Fill();
 238   ResetRecpoint();
 239
 240   fTOFLoader = fRunLoader->GetLoader("TOFLoader");
 241   fTOFLoader->WriteRecPoints("OVERWRITE");
 242
 243 }
 244 //______________________________________________________________________________
 245
 246 void AliTOFClusterFinder::Digits2RecPoints(AliRawReader *rawReader,
 247                                            TTree *clustersTree)
 248 {
 249   //
 250   // Converts RAW data to recpoints for TOF
 251   //
 252
 253   const Int_t kDDL = fTOFGeometry->NDDL()*fTOFGeometry->NSectors();
 254
 255   ResetRecpoint();
 256
 257   Int_t bufsize = 32000;
 258   clustersTree->Branch("TOF", &fRecPoints, bufsize);
 259
 260   Int_t ii = 0;
 261   Int_t indexDDL = 0;
 262
 263   Int_t detectorIndex[5];
 264   Float_t position[3];
 265   Double_t cylindricalPosition[5];
 266   Float_t tToT;
 267   Double_t tTdcND;
 268
 269   for (indexDDL = 0; indexDDL < kDDL; indexDDL++) {
 270
 271     rawReader->Reset();
 272     AliTOFRawStream tofInput(rawReader);
 273     rawReader->Select(5, indexDDL, indexDDL);
 274
 275     while(tofInput.Next()) {
 276
 277       detectorIndex[0] = tofInput.GetSector();
 278       detectorIndex[1] = tofInput.GetPlate();
 279       detectorIndex[2] = tofInput.GetStrip();
 280       detectorIndex[3] = tofInput.GetPadZ();
 281       detectorIndex[4] = tofInput.GetPadX();
 282
 283       for (ii=0; ii<3; ii++) position[ii] =  0.;
 284
 285       fTOFGeometry->GetPos(detectorIndex, position);
 286
 287       cylindricalPosition[0] = TMath::Sqrt(position[0]*position[0] + position[1]*position[1]);
 288       cylindricalPosition[1] = TMath::ATan2(position[1], position[0]);
 289       cylindricalPosition[2] = position[2];
 290       cylindricalPosition[3] = tofInput.GetTofBin();
 291       cylindricalPosition[4] = tofInput.GetADCbin();
 292       tToT = tofInput.GetADCbin();
 293       tTdcND = -1.;
 294       AliTOFcluster *tofCluster = new AliTOFcluster(cylindricalPosition, detectorIndex);
 295       tofCluster->SetToT(tToT);
 296       tofCluster->SetTDCND(tTdcND);
 297       InsertCluster(tofCluster);
 298
 299     } // while loop
 300
 301   } // loop on DDL files
 302
 303   AliInfo(Form("Number of found clusters: %i", fNumberOfTofClusters));
 304
 305   CalibrateRecPoint();
 306   FillRecPoint();
 307
 308   clustersTree->Fill();
 309
 310   ResetRecpoint();
 311
 312 }
 313 //______________________________________________________________________________
 314
 315 void AliTOFClusterFinder::Digits2RecPoints(Int_t iEvent, AliRawReader *rawReader)
 316 {
 317   //
 318   // Converts RAW data to recpoints for TOF
 319   //
 320
 321   const Int_t kDDL = fTOFGeometry->NDDL()*fTOFGeometry->NSectors();
 322
 323   fRunLoader->GetEvent(iEvent);
 324
 325   AliDebug(2,Form(" Event number %2i ", iEvent));
 326
 327   fTreeR = fTOFLoader->TreeR();
 328
 329   if (fTreeR == 0x0){
 330     fTOFLoader->MakeTree("R");
 331     fTreeR = fTOFLoader->TreeR();
 332   }
 333
 334   Int_t bufsize = 32000;
 335   fTreeR->Branch("TOF", &fRecPoints, bufsize);
 336
 337   Int_t ii = 0;
 338   Int_t indexDDL = 0;
 339
 340   Int_t detectorIndex[5];
 341   Float_t position[3];
 342   Double_t cylindricalPosition[5];
 343   Float_t tToT;
 344   Double_t tTdcND;
 345
 346   for (indexDDL = 0; indexDDL < kDDL; indexDDL++) {
 347
 348     rawReader->Reset();
 349     AliTOFRawStream tofInput(rawReader);
 350     rawReader->Select(5, indexDDL, indexDDL);
 351
 352     while(tofInput.Next()) {
 353
 354       detectorIndex[0] = (Int_t)tofInput.GetSector();
 355       detectorIndex[1] = (Int_t)tofInput.GetPlate();
 356       detectorIndex[2] = (Int_t)tofInput.GetStrip();
 357       detectorIndex[3] = (Int_t)tofInput.GetPadZ();
 358       detectorIndex[4] = (Int_t)tofInput.GetPadX();
 359
 360       for (ii=0; ii<3; ii++) position[ii] =  0.;
 361
 362       fTOFGeometry->GetPos(detectorIndex, position);
 363
 364       cylindricalPosition[0] = (Double_t)TMath::Sqrt(position[0]*position[0] + position[1]*position[1]);
 365       cylindricalPosition[1] = (Double_t)TMath::ATan2(position[1], position[0]);
 366       cylindricalPosition[2] = (Double_t)position[2];
 367       cylindricalPosition[3] = (Double_t)tofInput.GetTofBin();
 368       cylindricalPosition[4] = (Double_t)tofInput.GetADCbin();
 369       tToT = tofInput.GetADCbin();
 370       tTdcND = -1.;
 371
 372       AliTOFcluster *tofCluster = new AliTOFcluster(cylindricalPosition, detectorIndex);
 373       tofCluster->SetToT(tToT);
 374       tofCluster->SetTDCND(tTdcND);
 375       InsertCluster(tofCluster);
 376
 377     } // while loop
 378
 379   } // DDL Loop
 380
 381   AliInfo(Form("Number of found clusters: %i", fNumberOfTofClusters));
 382
 383   CalibrateRecPoint();
 384   FillRecPoint();
 385
 386   fTreeR->Fill();
 387   ResetRecpoint();
 388
 389   fTOFLoader = fRunLoader->GetLoader("TOFLoader");
 390   fTOFLoader->WriteRecPoints("OVERWRITE");
 391
 392 }
 393 //______________________________________________________________________________
 394
 395 void AliTOFClusterFinder::Raw2Digits(Int_t iEvent, AliRawReader *rawReader)
 396 {
 397   //
 398   // Converts RAW data to MC digits for TOF
 399   //
 400   //             (temporary solution)
 401   //
 402
 403   fRunLoader->GetEvent(iEvent);
 404
 405   fTreeD = fTOFLoader->TreeD();
 406   if (fTreeD)
 407     {
 408     AliInfo("AliTOFClusterFinder: TreeD re-creation");
 409     fTreeD = 0x0;
 410     fTOFLoader->MakeTree("D");
 411     fTreeD = fTOFLoader->TreeD();
 412     }
 413
 414
 415   fTreeR = fTOFLoader->TreeD();
 416   if (fTreeD == 0x0)
 417     {
 418       fTOFLoader->MakeTree("D");
 419       fTreeD = fTOFLoader->TreeD();
 420     }
 421
 422   TClonesArray dummy("AliTOFdigit",10000), *tofDigits=&dummy;
 423   Int_t bufsize = 32000;
 424   fTreeD->Branch("TOF", &tofDigits, bufsize);
 425
 426
 427   const Int_t kDDL = fTOFGeometry->NDDL()*fTOFGeometry->NSectors();
 428
 429   fRunLoader->GetEvent(iEvent);
 430
 431   AliDebug(2,Form(" Event number %2i ", iEvent));
 432
 433   Int_t indexDDL = 0;
 434
 435   Int_t detectorIndex[5];
 436   Float_t digit[2];
 437
 438   for (indexDDL = 0; indexDDL < kDDL; indexDDL++) {
 439
 440     rawReader->Reset();
 441     AliTOFRawStream tofInput(rawReader);
 442     rawReader->Select(5, indexDDL, indexDDL);
 443
 444     while(tofInput.Next()) {
 445
 446       detectorIndex[0] = tofInput.GetSector();
 447       detectorIndex[1] = tofInput.GetPlate();
 448       detectorIndex[2] = tofInput.GetStrip();
 449       detectorIndex[3] = tofInput.GetPadX();
 450       detectorIndex[4] = tofInput.GetPadZ();
 451
 452       digit[0] = (Float_t)tofInput.GetTofBin();
 453       digit[1] = (Float_t)tofInput.GetADCbin();
 454
 455       Int_t tracknum[3]={-1,-1,-1};
 456
 457       TClonesArray &aDigits = *tofDigits;
 458       Int_t last=tofDigits->GetEntriesFast();
 459       new (aDigits[last]) AliTOFdigit(tracknum, detectorIndex, digit);
 460
 461     } // while loop
 462
 463   } // DDL Loop
 464
 465   fTreeD->Fill();
 466
 467   fTOFLoader = fRunLoader->GetLoader("TOFLoader");
 468   fTOFLoader->WriteDigits("OVERWRITE");
 469
 470 }
 471 //______________________________________________________________________________
 472
 473 Int_t AliTOFClusterFinder::InsertCluster(AliTOFcluster *tofCluster) {
 474   //---------------------------------------------------------------------------//
 475   // This function adds a TOF cluster to the array of TOF clusters sorted in Z //
 476   //---------------------------------------------------------------------------//
 477   if (fNumberOfTofClusters==kTofMaxCluster) {
 478     AliError("Too many clusters !");
 479     return 1;
 480   }
 481
 482   if (fNumberOfTofClusters==0) {
 483     fTofClusters[fNumberOfTofClusters++] = tofCluster;
 484     return 0;
 485   }
 486
 487   Int_t ii = FindClusterIndex(tofCluster->GetZ());
 488   memmove(fTofClusters+ii+1 ,fTofClusters+ii,(fNumberOfTofClusters-ii)*sizeof(AliTOFcluster*));
 489   fTofClusters[ii] = tofCluster;
 490   fNumberOfTofClusters++;
 491
 492   return 0;
 493
 494 }
 495 //_________________________________________________________________________
 496
 497 Int_t AliTOFClusterFinder::FindClusterIndex(Double_t z) const {
 498   //--------------------------------------------------------------------
 499   // This function returns the index of the nearest cluster
 500   //--------------------------------------------------------------------
 501   if (fNumberOfTofClusters==0) return 0;
 502   if (z <= fTofClusters[0]->GetZ()) return 0;
 503   if (z > fTofClusters[fNumberOfTofClusters-1]->GetZ()) return fNumberOfTofClusters;
 504   Int_t b = 0, e = fNumberOfTofClusters-1, m = (b+e)/2;
 505   for (; b<e; m=(b+e)/2) {
 506     if (z > fTofClusters[m]->GetZ()) b=m+1;
 507     else e=m;
 508   }
 509
 510   return m;
 511
 512 }
 513 //_________________________________________________________________________
 514
 515 void AliTOFClusterFinder::FillRecPoint()
 516 {
 517   //
 518   // Copy the global array of AliTOFcluster, i.e. fTofClusters (sorted
 519   // in Z) in the global TClonesArray of AliTOFcluster,
 520   // i.e. fRecPoints.
 521   //
 522
 523   Int_t ii, jj;
 524
 525   Int_t detectorIndex[5];
 526   Double_t cylindricalPosition[5];
 527   Int_t trackLabels[3];
 528   Int_t digitIndex = -1;
 529   Float_t tToT;
 530   Double_t tTdcND;
 531
 532   TClonesArray &lRecPoints = *fRecPoints;
 533
 534   for (ii=0; ii<fNumberOfTofClusters; ii++) {
 535
 536     digitIndex = fTofClusters[ii]->GetIndex();
 537     for(jj=0; jj<5; jj++) detectorIndex[jj] = fTofClusters[ii]->GetDetInd(jj);
 538     for(jj=0; jj<3; jj++) trackLabels[jj] = fTofClusters[ii]->GetLabel(jj);
 539     cylindricalPosition[0] = fTofClusters[ii]->GetR();
 540     cylindricalPosition[1] = fTofClusters[ii]->GetPhi();
 541     cylindricalPosition[2] = fTofClusters[ii]->GetZ();
 542     cylindricalPosition[3] = fTofClusters[ii]->GetTDC();
 543     cylindricalPosition[4] = fTofClusters[ii]->GetADC();
 544     tToT = fTofClusters[ii]->GetToT();
 545     tTdcND = fTofClusters[ii]->GetTDCND();
 546
 547     new(lRecPoints[ii]) AliTOFcluster(cylindricalPosition, trackLabels, detectorIndex, digitIndex, tToT, tTdcND);
 548
 549     //AliInfo(Form("%3i  %3i  %f %f %f %f %f  %2i %2i %2i %1i %2i",ii,digitIndex, cylindricalPosition[2],cylindricalPosition[0],cylindricalPosition[1],cylindricalPosition[3],cylindricalPosition[4],detectorIndex[0],detectorIndex[1],detectorIndex[2],detectorIndex[3],detectorIndex[4]));
 550
 551   } // loop on clusters
 552
 553 }
 554
 555 //_________________________________________________________________________
 556 void AliTOFClusterFinder::CalibrateRecPoint()
 557 {
 558   //
 559   // Copy the global array of AliTOFcluster, i.e. fTofClusters (sorted
 560   // in Z) in the global TClonesArray of AliTOFcluster,
 561   // i.e. fRecPoints.
 562   //
 563
 564   Int_t ii, jj;
 565
 566   Int_t detectorIndex[5];
 567   Int_t digitIndex = -1;
 568   Float_t tToT;
 569   Float_t tdcCorr;
 570   AliInfo(" Calibrating TOF Clusters: ")
 571   AliTOFcalib *calib = new AliTOFcalib(fTOFGeometry);
 572   // calib->ReadParFromCDB("TOF/Calib",0); // original
 573   calib->ReadParFromCDB("TOF/Calib",-1); // Use AliCDBManager's run number
 574   AliTOFCal *calTOFArray = calib->GetTOFCalArray();
 575
 576   for (ii=0; ii<fNumberOfTofClusters; ii++) {
 577     digitIndex = fTofClusters[ii]->GetIndex();
 578     for(jj=0; jj<5; jj++) detectorIndex[jj] = fTofClusters[ii]->GetDetInd(jj);
 579
 580     Int_t index = calib->GetIndex(detectorIndex);
 581
 582     AliTOFChannel * calChannel = calTOFArray->GetChannel(index);
 583     Float_t par[6];
 584     for (Int_t j = 0; j<6; j++){
 585       par[j]=calChannel->GetSlewPar(j);
 586     }
 587     tToT = fTofClusters[ii]->GetToT();
 588     Float_t timeCorr=par[0]+par[1]*tToT+par[2]*tToT*tToT+par[3]*tToT*tToT*tToT+par[4]*tToT*tToT*tToT*tToT+par[5]*tToT*tToT*tToT*tToT*tToT;
 589     tdcCorr=(fTofClusters[ii]->GetTDC()*AliTOFGeometry::TdcBinWidth()+32)*1.E-3-timeCorr;
 590     tdcCorr=(tdcCorr*1E3-32)/AliTOFGeometry::TdcBinWidth();
 591     fTofClusters[ii]->SetTDC(tdcCorr);
 592
 593   } // loop on clusters
 594
 595   delete calib;
 596 }
 597 //______________________________________________________________________________
 598
 599 void AliTOFClusterFinder::ResetRecpoint()
 600 {
 601   //
 602   // Clear the list of reconstructed points
 603   //
 604
 605   fNumberOfTofClusters = 0;
 606   if (fRecPoints) fRecPoints->Clear();
 607
 608 }
 609 //______________________________________________________________________________
 610
 611 void AliTOFClusterFinder::Load()
 612 {
 613   //
 614   // Load TOF.Digits.root and TOF.RecPoints.root files
 615   //
 616
 617   fTOFLoader->LoadDigits("READ");
 618   fTOFLoader->LoadRecPoints("recreate");
 619
 620 }
 621 //______________________________________________________________________________
 622
 623 void AliTOFClusterFinder::LoadClusters()
 624 {
 625   //
 626   // Load TOF.RecPoints.root file
 627   //
 628
 629   fTOFLoader->LoadRecPoints("recreate");
 630
 631 }
 632 //______________________________________________________________________________
 633
 634 void AliTOFClusterFinder::UnLoad()
 635 {
 636   //
 637   // Unload TOF.Digits.root and TOF.RecPoints.root files
 638   //
 639
 640   fTOFLoader->UnloadDigits();
 641   fTOFLoader->UnloadRecPoints();
 642
 643 }
 644 //______________________________________________________________________________
 645
 646 void AliTOFClusterFinder::UnLoadClusters()
 647 {
 648   //
 649   // Unload TOF.RecPoints.root file
 650   //
 651
 652   fTOFLoader->UnloadRecPoints();
 653
 654 }
 655 //______________________________________________________________________________