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