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