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