PMD/AliPMDClusterFinder.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 //           Date   : August 05 2003                   //
  19 //  This reads the file PMD.digits.root(TreeD),        //
  20 //  calls the Clustering algorithm and stores the      //
  21 //  clustering output in PMD.RecPoints.root(TreeR)     //
  22 //                                                     //
  23 //-----------------------------------------------------//
  24
  25 #include <Riostream.h>
  26 #include <TTree.h>
  27 #include <TObjArray.h>
  28 #include <TClonesArray.h>
  29
  30 #include "AliLog.h"
  31 #include "AliRunLoader.h"
  32 #include "AliLoader.h"
  33 #include "AliRawReader.h"
  34
  35 #include "AliPMDdigit.h"
  36 #include "AliPMDClusterFinder.h"
  37 #include "AliPMDClustering.h"
  38 #include "AliPMDClusteringV1.h"
  39 #include "AliPMDcluster.h"
  40 #include "AliPMDrecpoint1.h"
  41 #include "AliPMDrechit.h"
  42 #include "AliPMDRawStream.h"
  43
  44
  45
  46 ClassImp(AliPMDClusterFinder)
  47
  48 AliPMDClusterFinder::AliPMDClusterFinder():
  49   fRunLoader(0),
  50   fPMDLoader(0),
  51   fTreeD(0),
  52   fTreeR(0),
  53   fDigits(new TClonesArray("AliPMDdigit", 1000)),
  54   fRecpoints(new TClonesArray("AliPMDrecpoint1", 1000)),
  55   fRechits(new TClonesArray("AliPMDrechit", 1000)),
  56   fNpoint(0),
  57   fNhit(0),
  58   fEcut(0.)
  59 {
  60 //
  61 // Constructor
  62 //
  63 }
  64 // ------------------------------------------------------------------------- //
  65 AliPMDClusterFinder::AliPMDClusterFinder(AliRunLoader* runLoader):
  66   fRunLoader(runLoader),
  67   fPMDLoader(runLoader->GetLoader("PMDLoader")),
  68   fTreeD(0),
  69   fTreeR(0),
  70   fDigits(new TClonesArray("AliPMDdigit", 1000)),
  71   fRecpoints(new TClonesArray("AliPMDrecpoint1", 1000)),
  72   fRechits(new TClonesArray("AliPMDrechit", 1000)),
  73   fNpoint(0),
  74   fNhit(0),
  75   fEcut(0.)
  76 {
  77 //
  78 // Constructor
  79 //
  80 }
  81 // ------------------------------------------------------------------------- //
  82 AliPMDClusterFinder::~AliPMDClusterFinder()
  83 {
  84   // Destructor
  85   if (fDigits)
  86     {
  87       fDigits->Delete();
  88       delete fDigits;
  89       fDigits=0;
  90     }
  91   if (fRecpoints)
  92     {
  93       fRecpoints->Delete();
  94       delete fRecpoints;
  95       fRecpoints=0;
  96     }
  97   if (fRechits)
  98     {
  99       fRechits->Delete();
 100       delete fRechits;
 101       fRechits=0;
 102     }
 103 }
 104 // ------------------------------------------------------------------------- //
 105
 106 void AliPMDClusterFinder::Digits2RecPoints(Int_t ievt)
 107 {
 108   // Converts digits to recpoints after running clustering
 109   // algorithm on CPV plane and PREshower plane
 110   //
 111   Int_t    det = 0,smn = 0;
 112   Int_t    xpos,ypos;
 113   Float_t  adc;
 114   Int_t    ismn;
 115   Int_t    idet;
 116   Float_t  clusdata[6];
 117
 118   TObjArray *pmdcont = new TObjArray();
 119   AliPMDClustering *pmdclust = new AliPMDClusteringV1();
 120
 121   pmdclust->SetEdepCut(fEcut);
 122
 123   fRunLoader->GetEvent(ievt);
 124
 125
 126   fTreeD = fPMDLoader->TreeD();
 127   if (fTreeD == 0x0)
 128     {
 129       AliFatal("AliPMDClusterFinder: Can not get TreeD");
 130
 131     }
 132   AliPMDdigit  *pmddigit;
 133   TBranch *branch = fTreeD->GetBranch("PMDDigit");
 134   branch->SetAddress(&fDigits);
 135
 136   ResetRecpoint();
 137
 138   fTreeR = fPMDLoader->TreeR();
 139   if (fTreeR == 0x0)
 140     {
 141       fPMDLoader->MakeTree("R");
 142       fTreeR = fPMDLoader->TreeR();
 143     }
 144
 145   Int_t bufsize = 16000;
 146   TBranch * branch1 = fTreeR->Branch("PMDRecpoint", &fRecpoints, bufsize);
 147   TBranch * branch2 = fTreeR->Branch("PMDRechit", &fRechits, bufsize);
 148
 149   Int_t nmodules = (Int_t) fTreeD->GetEntries();
 150
 151   for (Int_t imodule = 0; imodule < nmodules; imodule++)
 152     {
 153       ResetCellADC();
 154       fTreeD->GetEntry(imodule);
 155       Int_t nentries = fDigits->GetLast();
 156       for (Int_t ient = 0; ient < nentries+1; ient++)
 157         {
 158           pmddigit = (AliPMDdigit*)fDigits->UncheckedAt(ient);
 159
 160           det    = pmddigit->GetDetector();
 161           smn    = pmddigit->GetSMNumber();
 162           xpos   = pmddigit->GetRow();
 163           ypos   = pmddigit->GetColumn();
 164           adc    = pmddigit->GetADC();
 165           //Int_t trno   = pmddigit->GetTrackNumber();
 166           fCellADC[xpos][ypos] = (Double_t) adc;
 167         }
 168
 169       idet = det;
 170       ismn = smn;
 171       pmdclust->DoClust(idet,ismn,fCellADC,pmdcont);
 172
 173       Int_t nentries1 = pmdcont->GetEntries();
 174
 175       AliDebug(1,Form("Total number of clusters/module = %d",nentries1));
 176
 177       for (Int_t ient1 = 0; ient1 < nentries1; ient1++)
 178         {
 179           AliPMDcluster *pmdcl = (AliPMDcluster*)pmdcont->UncheckedAt(ient1);
 180           idet        = pmdcl->GetDetector();
 181           ismn        = pmdcl->GetSMN();
 182           clusdata[0] = pmdcl->GetClusX();
 183           clusdata[1] = pmdcl->GetClusY();
 184           clusdata[2] = pmdcl->GetClusADC();
 185           clusdata[3] = pmdcl->GetClusCells();
 186           clusdata[4] = pmdcl->GetClusSigmaX();
 187           clusdata[5] = pmdcl->GetClusSigmaY();
 188
 189           AddRecPoint(idet,ismn,clusdata);
 190
 191           // This part will be worked out
 192           // BKN
 193           Int_t ncell = (Int_t) clusdata[3];
 194           for(Int_t ihit = 0; ihit < ncell; ihit++)
 195             {
 196               Int_t celldataX = pmdcl->GetClusCellX(ihit);
 197               Int_t celldataY = pmdcl->GetClusCellY(ihit);
 198               AddRecHit(celldataX, celldataY);
 199             }
 200           branch2->Fill();
 201           ResetRechit();
 202         }
 203       pmdcont->Clear();
 204
 205       branch1->Fill();
 206       ResetRecpoint();
 207
 208     } // modules
 209
 210   ResetCellADC();
 211   fPMDLoader = fRunLoader->GetLoader("PMDLoader");
 212   fPMDLoader->WriteRecPoints("OVERWRITE");
 213
 214   //   delete the pointers
 215   delete pmdclust;
 216   delete pmdcont;
 217
 218 }
 219 // ------------------------------------------------------------------------- //
 220
 221 void AliPMDClusterFinder::Digits2RecPoints(AliRawReader *rawReader,
 222                                            TTree *clustersTree)
 223 {
 224   // Converts RAW data to recpoints after running clustering
 225   // algorithm on CPV and PREshower plane
 226   //
 227
 228   Float_t  clusdata[6];
 229
 230   TObjArray *pmdcont = new TObjArray();
 231   AliPMDClustering *pmdclust = new AliPMDClusteringV1();
 232
 233   pmdclust->SetEdepCut(fEcut);
 234
 235   ResetRecpoint();
 236
 237   Int_t bufsize = 16000;
 238   TBranch *branch1 = clustersTree->Branch("PMDRecpoint", &fRecpoints, bufsize);
 239
 240   TBranch * branch2 = clustersTree->Branch("PMDRechit", &fRechits, bufsize);
 241
 242   const Int_t kDDL = 6;
 243   const Int_t kRow = 48;
 244   const Int_t kCol = 96;
 245
 246   Int_t idet = 0;
 247   Int_t iSMN = 0;
 248
 249   for (Int_t indexDDL = 0; indexDDL < kDDL; indexDDL++)
 250     {
 251       if (indexDDL < 4)
 252         {
 253           iSMN = 6;
 254         }
 255       else if (indexDDL >= 4)
 256         {
 257           iSMN = 12;
 258         }
 259       Int_t ***precpvADC;
 260       precpvADC = new int **[iSMN];
 261       for (Int_t i=0; i<iSMN; i++) precpvADC[i] = new int *[kRow];
 262       for (Int_t i=0; i<iSMN;i++)
 263         {
 264           for (Int_t j=0; j<kRow; j++) precpvADC[i][j] = new int [kCol];
 265         }
 266       for (Int_t i = 0; i < iSMN; i++)
 267         {
 268           for (Int_t j = 0; j < kRow; j++)
 269             {
 270               for (Int_t k = 0; k < kCol; k++)
 271                 {
 272                   precpvADC[i][j][k] = 0;
 273                 }
 274             }
 275         }
 276       ResetCellADC();
 277       rawReader->Reset();
 278       AliPMDRawStream pmdinput(rawReader);
 279       rawReader->Select(12, indexDDL, indexDDL);
 280       while(pmdinput.Next())
 281         {
 282           Int_t det = pmdinput.GetDetector();
 283           Int_t smn = pmdinput.GetSMN();
 284           //Int_t mcm = pmdinput.GetMCM();
 285           //Int_t chno = pmdinput.GetChannel();
 286           Int_t row = pmdinput.GetRow();
 287           Int_t col = pmdinput.GetColumn();
 288           Int_t sig = pmdinput.GetSignal();
 289
 290           Int_t indexsmn = 0;
 291
 292           if (indexDDL < 4)
 293             {
 294               if (det != 0)
 295                 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
 296                               indexDDL, det));
 297               indexsmn = smn - indexDDL * 6;
 298             }
 299           else if (indexDDL == 4)
 300             {
 301               if (det != 1)
 302                 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
 303                               indexDDL, det));
 304               if (smn < 6)
 305                 {
 306                   indexsmn = smn;
 307                 }
 308               else if (smn >= 12 && smn < 18)
 309                 {
 310                   indexsmn = smn - 6;
 311                 }
 312             }
 313           else if (indexDDL == 5)
 314             {
 315               if (det != 1)
 316                 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
 317                               indexDDL, det));
 318               if (smn >= 6 && smn < 12)
 319                 {
 320                   indexsmn = smn - 6;
 321                 }
 322               else if (smn >= 18 && smn < 24)
 323                 {
 324                   indexsmn = smn - 12;
 325                 }
 326             }
 327           precpvADC[indexsmn][row][col] = sig;
 328         } // while loop
 329
 330       Int_t ismn = 0;
 331       for (Int_t indexsmn = 0; indexsmn < iSMN; indexsmn++)
 332         {
 333           ResetCellADC();
 334           for (Int_t irow = 0; irow < kRow; irow++)
 335             {
 336               for (Int_t icol = 0; icol < kCol; icol++)
 337                 {
 338                   fCellADC[irow][icol] =
 339                     (Double_t) precpvADC[indexsmn][irow][icol];
 340                 } // row
 341             }     // col
 342           if (indexDDL < 4)
 343             {
 344               ismn = indexsmn + indexDDL * 6;
 345               idet = 0;
 346             }
 347           else if (indexDDL == 4)
 348             {
 349               if (indexsmn < 6)
 350                 {
 351                   ismn = indexsmn;
 352                 }
 353               else if (indexsmn >= 6 && indexsmn < 12)
 354                 {
 355                   ismn = indexsmn + 6;
 356                 }
 357               idet = 1;
 358             }
 359           else if (indexDDL == 5)
 360             {
 361               if (indexsmn < 6)
 362                 {
 363                   ismn = indexsmn + 6;
 364                 }
 365               else if (indexsmn >= 6 && indexsmn < 12)
 366                 {
 367                   ismn = indexsmn + 12;
 368                 }
 369               idet = 1;
 370             }
 371
 372
 373           pmdclust->DoClust(idet,ismn,fCellADC,pmdcont);
 374           Int_t nentries1 = pmdcont->GetEntries();
 375
 376           AliDebug(1,Form("Total number of clusters/module = %d",nentries1));
 377
 378           for (Int_t ient1 = 0; ient1 < nentries1; ient1++)
 379             {
 380               AliPMDcluster *pmdcl =
 381                 (AliPMDcluster*)pmdcont->UncheckedAt(ient1);
 382               idet        = pmdcl->GetDetector();
 383               ismn        = pmdcl->GetSMN();
 384               clusdata[0] = pmdcl->GetClusX();
 385               clusdata[1] = pmdcl->GetClusY();
 386               clusdata[2] = pmdcl->GetClusADC();
 387               clusdata[3] = pmdcl->GetClusCells();
 388               clusdata[4] = pmdcl->GetClusSigmaX();
 389               clusdata[5] = pmdcl->GetClusSigmaY();
 390
 391               AddRecPoint(idet,ismn,clusdata);
 392               // BKN
 393               Int_t ncell = (Int_t) clusdata[3];
 394               for(Int_t ihit = 0; ihit < ncell; ihit++)
 395                 {
 396                   Int_t celldataX = pmdcl->GetClusCellX(ihit);
 397                   Int_t celldataY = pmdcl->GetClusCellY(ihit);
 398                   AddRecHit(celldataX, celldataY);
 399                 }
 400               branch2->Fill();
 401               ResetRechit();
 402
 403             }
 404           pmdcont->Clear();
 405
 406           branch1->Fill();
 407           ResetRecpoint();
 408
 409
 410         } // smn
 411
 412       for (Int_t i=0; i<iSMN; i++)
 413         {
 414           for (Int_t j=0; j<kRow; j++) delete [] precpvADC[i][j];
 415         }
 416       for (Int_t i=0; i<iSMN; i++) delete [] precpvADC[i];
 417       delete precpvADC;
 418     } // DDL Loop
 419
 420   ResetCellADC();
 421
 422   //   delete the pointers
 423   delete pmdclust;
 424   delete pmdcont;
 425
 426 }
 427 // ------------------------------------------------------------------------- //
 428
 429 void AliPMDClusterFinder::Digits2RecPoints(Int_t ievt, AliRawReader *rawReader)
 430 {
 431   // Converts RAW data to recpoints after running clustering
 432   // algorithm on CPV and PREshower plane
 433   //
 434
 435   Float_t  clusdata[6];
 436
 437   TObjArray *pmdcont = new TObjArray();
 438
 439   AliPMDClustering *pmdclust = new AliPMDClusteringV1();
 440
 441   pmdclust->SetEdepCut(fEcut);
 442
 443   fRunLoader->GetEvent(ievt);
 444
 445   ResetRecpoint();
 446
 447   fTreeR = fPMDLoader->TreeR();
 448   if (fTreeR == 0x0)
 449     {
 450       fPMDLoader->MakeTree("R");
 451       fTreeR = fPMDLoader->TreeR();
 452     }
 453   Int_t bufsize = 16000;
 454   TBranch *branch1 = fTreeR->Branch("PMDRecpoint", &fRecpoints, bufsize);
 455   TBranch *branch2 = fTreeR->Branch("PMDRechit", &fRechits, bufsize);
 456
 457   const Int_t kDDL = 6;
 458   const Int_t kRow = 48;
 459   const Int_t kCol = 96;
 460
 461   Int_t idet = 0;
 462   Int_t iSMN = 0;
 463
 464   for (Int_t indexDDL = 0; indexDDL < kDDL; indexDDL++)
 465     {
 466       if (indexDDL < 4)
 467         {
 468           iSMN = 6;
 469         }
 470       else if (indexDDL >= 4)
 471         {
 472           iSMN = 12;
 473         }
 474       Int_t ***precpvADC;
 475       precpvADC = new int **[iSMN];
 476       for (Int_t i=0; i<iSMN; i++) precpvADC[i] = new int *[kRow];
 477       for (Int_t i=0; i<iSMN;i++)
 478         {
 479           for (Int_t j=0; j<kRow; j++) precpvADC[i][j] = new int [kCol];
 480         }
 481       for (Int_t i = 0; i < iSMN; i++)
 482         {
 483           for (Int_t j = 0; j < kRow; j++)
 484             {
 485               for (Int_t k = 0; k < kCol; k++)
 486                 {
 487                   precpvADC[i][j][k] = 0;
 488                 }
 489             }
 490         }
 491       ResetCellADC();
 492       rawReader->Reset();
 493       AliPMDRawStream pmdinput(rawReader);
 494       rawReader->Select(12, indexDDL, indexDDL);
 495       while(pmdinput.Next())
 496         {
 497           Int_t det = pmdinput.GetDetector();
 498           Int_t smn = pmdinput.GetSMN();
 499           //Int_t mcm = pmdinput.GetMCM();
 500           //Int_t chno = pmdinput.GetChannel();
 501           Int_t row = pmdinput.GetRow();
 502           Int_t col = pmdinput.GetColumn();
 503           Int_t sig = pmdinput.GetSignal();
 504
 505           Int_t indexsmn = 0;
 506
 507           if (indexDDL < 4)
 508             {
 509               if (det != 0)
 510                 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
 511                               indexDDL, det));
 512               indexsmn = smn - indexDDL * 6;
 513             }
 514           else if (indexDDL == 4)
 515             {
 516               if (det != 1)
 517                 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
 518                               indexDDL, det));
 519               if (smn < 6)
 520                 {
 521                   indexsmn = smn;
 522                 }
 523               else if (smn >= 12 && smn < 18)
 524                 {
 525                   indexsmn = smn - 6;
 526                 }
 527             }
 528           else if (indexDDL == 5)
 529             {
 530               if (det != 1)
 531                 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
 532                               indexDDL, det));
 533               if (smn >= 6 && smn < 12)
 534                 {
 535                   indexsmn = smn - 6;
 536                 }
 537               else if (smn >= 18 && smn < 24)
 538                 {
 539                   indexsmn = smn - 12;
 540                 }
 541             }
 542           precpvADC[indexsmn][row][col] = sig;
 543         } // while loop
 544
 545       Int_t ismn = 0;
 546       for (Int_t indexsmn = 0; indexsmn < iSMN; indexsmn++)
 547         {
 548           ResetCellADC();
 549           for (Int_t irow = 0; irow < kRow; irow++)
 550             {
 551               for (Int_t icol = 0; icol < kCol; icol++)
 552                 {
 553                   fCellADC[irow][icol] =
 554                     (Double_t) precpvADC[indexsmn][irow][icol];
 555                 } // row
 556             }     // col
 557           if (indexDDL < 4)
 558             {
 559               ismn = indexsmn + indexDDL * 6;
 560               idet = 0;
 561             }
 562           else if (indexDDL == 4)
 563             {
 564               if (indexsmn < 6)
 565                 {
 566                   ismn = indexsmn;
 567                 }
 568               else if (indexsmn >= 6 && indexsmn < 12)
 569                 {
 570                   ismn = indexsmn + 6;
 571                 }
 572               idet = 1;
 573             }
 574           else if (indexDDL == 5)
 575             {
 576               if (indexsmn < 6)
 577                 {
 578                   ismn = indexsmn + 6;
 579                 }
 580               else if (indexsmn >= 6 && indexsmn < 12)
 581                 {
 582                   ismn = indexsmn + 12;
 583                 }
 584               idet = 1;
 585             }
 586
 587
 588           pmdclust->DoClust(idet,ismn,fCellADC,pmdcont);
 589           Int_t nentries1 = pmdcont->GetEntries();
 590
 591           AliDebug(1,Form("Total number of clusters/module = %d",nentries1));
 592
 593           for (Int_t ient1 = 0; ient1 < nentries1; ient1++)
 594             {
 595               AliPMDcluster *pmdcl =
 596                 (AliPMDcluster*)pmdcont->UncheckedAt(ient1);
 597               idet        = pmdcl->GetDetector();
 598               ismn        = pmdcl->GetSMN();
 599               clusdata[0] = pmdcl->GetClusX();
 600               clusdata[1] = pmdcl->GetClusY();
 601               clusdata[2] = pmdcl->GetClusADC();
 602               clusdata[3] = pmdcl->GetClusCells();
 603               clusdata[4] = pmdcl->GetClusSigmaX();
 604               clusdata[5] = pmdcl->GetClusSigmaY();
 605
 606               AddRecPoint(idet,ismn,clusdata);
 607
 608               // BKN
 609               Int_t ncell = (Int_t) clusdata[3];
 610               for(Int_t ihit = 0; ihit < ncell; ihit++)
 611                 {
 612                   Int_t celldataX = pmdcl->GetClusCellX(ihit);
 613                   Int_t celldataY = pmdcl->GetClusCellY(ihit);
 614                   AddRecHit(celldataX, celldataY);
 615                 }
 616               branch2->Fill();
 617               ResetRechit();
 618
 619             }
 620           pmdcont->Clear();
 621
 622           branch1->Fill();
 623           ResetRecpoint();
 624
 625
 626         } // smn
 627
 628       for (Int_t i=0; i<iSMN; i++)
 629         {
 630           for (Int_t j=0; j<kRow; j++) delete [] precpvADC[i][j];
 631         }
 632       for (Int_t i=0; i<iSMN; i++) delete [] precpvADC[i];
 633       delete precpvADC;
 634     } // DDL Loop
 635
 636   ResetCellADC();
 637
 638   fPMDLoader = fRunLoader->GetLoader("PMDLoader");
 639   fPMDLoader->WriteRecPoints("OVERWRITE");
 640
 641   //   delete the pointers
 642   delete pmdclust;
 643   delete pmdcont;
 644
 645 }
 646 // ------------------------------------------------------------------------- //
 647 void AliPMDClusterFinder::SetCellEdepCut(Float_t ecut)
 648 {
 649   fEcut = ecut;
 650 }
 651 // ------------------------------------------------------------------------- //
 652 void AliPMDClusterFinder::AddRecPoint(Int_t idet,Int_t ismn,Float_t *clusdata)
 653 {
 654   // Add Reconstructed points
 655   //
 656   TClonesArray &lrecpoints = *fRecpoints;
 657   AliPMDrecpoint1 *newrecpoint;
 658   newrecpoint = new AliPMDrecpoint1(idet, ismn, clusdata);
 659   new(lrecpoints[fNpoint++]) AliPMDrecpoint1(newrecpoint);
 660   delete newrecpoint;
 661 }
 662 // ------------------------------------------------------------------------- //
 663 void AliPMDClusterFinder::AddRecHit(Int_t celldataX,Int_t celldataY)
 664 {
 665   // Add associated cell hits to the Reconstructed points
 666   //
 667   TClonesArray &lrechits = *fRechits;
 668   AliPMDrechit *newrechit;
 669   newrechit = new AliPMDrechit(celldataX, celldataY);
 670   new(lrechits[fNhit++]) AliPMDrechit(newrechit);
 671   delete newrechit;
 672 }
 673 // ------------------------------------------------------------------------- //
 674 void AliPMDClusterFinder::ResetCellADC()
 675 {
 676   // Reset the individual cell ADC value to zero
 677   //
 678   for(Int_t irow = 0; irow < fgkRow; irow++)
 679     {
 680       for(Int_t icol = 0; icol < fgkCol; icol++)
 681         {
 682           fCellADC[irow][icol] = 0.;
 683         }
 684     }
 685 }
 686 // ------------------------------------------------------------------------- //
 687
 688 void AliPMDClusterFinder::ResetRecpoint()
 689 {
 690   // Clear the list of reconstructed points
 691   fNpoint = 0;
 692   if (fRecpoints) fRecpoints->Clear();
 693 }
 694 // ------------------------------------------------------------------------- //
 695 void AliPMDClusterFinder::ResetRechit()
 696 {
 697   // Clear the list of reconstructed points
 698   fNhit = 0;
 699   if (fRechits) fRechits->Clear();
 700 }
 701 // ------------------------------------------------------------------------- //
 702 void AliPMDClusterFinder::Load()
 703 {
 704   // Load all the *.root files
 705   //
 706   fPMDLoader->LoadDigits("READ");
 707   fPMDLoader->LoadRecPoints("recreate");
 708 }
 709 // ------------------------------------------------------------------------- //
 710 void AliPMDClusterFinder::LoadClusters()
 711 {
 712   // Load all the *.root files
 713   //
 714   fPMDLoader->LoadRecPoints("recreate");
 715 }
 716 // ------------------------------------------------------------------------- //
 717 void AliPMDClusterFinder::UnLoad()
 718 {
 719   // Unload all the *.root files
 720   //
 721   fPMDLoader->UnloadDigits();
 722   fPMDLoader->UnloadRecPoints();
 723 }
 724 // ------------------------------------------------------------------------- //
 725 void AliPMDClusterFinder::UnLoadClusters()
 726 {
 727   // Unload all the *.root files
 728   //
 729   fPMDLoader->UnloadRecPoints();
 730 }
 731 // ------------------------------------------------------------------------- //