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