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