macro title as filename
[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       AliPMDRecoParam * par = fRecoParam->GetPPParam();
273       Int_t cluspar = par->GetClusteringParam();
274       delete par;
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           AliPMDRecoParam * par = fRecoParam->GetPPParam();
601            Int_t cluspar = par->GetClusteringParam();
602            delete par;
603           // Int_t cluspar = fRecoParam->GetCosmicParam()->GetClusteringParam();
604
605           //_______________________________________________________// 
606           //Added to switch Refine and crude Clustering - satya//
607           // temporary solution - will be sorted out later
608           /* cluspar = 1;
609           static AliPMDRecoParam *reconp = NULL;
610           reconp = (AliPMDRecoParam*)AliPMDReconstructor::GetRecoParam();
611           if(!reconp) {
612             cluspar = 1;
613           } 
614           else { 
615             if( reconp->GetClusteringParam() == 1) 
616               cluspar = 1;
617             if( reconp->GetClusteringParam() == 2) 
618               cluspar = 2;
619           }*/
620
621
622           cluspar = gRecoMode; // permanent solution
623
624           //_______________________________________________________// 
625
626           pmdclust->SetClusteringParam(cluspar);
627           Float_t encut = fNoiseCut->GetNoiseCut(imod);
628
629           pmdclust->SetEdepCut(encut);
630           pmdclust->DoClust(idet,ismn,fCellTrack,fCellPid,fCellADC,pmdcont);
631
632           Int_t nentries1 = pmdcont->GetEntries();
633
634           AliDebug(1,Form("Total number of clusters/module = %d",nentries1));
635
636           for (Int_t ient1 = 0; ient1 < nentries1; ient1++)
637             {
638               pmdcl = (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               if (ncell > 19) ncell = 19;
652               for(Int_t ihit = 0; ihit < ncell; ihit++)
653                 {
654                   Int_t celldataX = pmdcl->GetClusCellX(ihit);
655                   Int_t celldataY = pmdcl->GetClusCellY(ihit);
656                   Int_t celldataTr = pmdcl->GetClusCellTrack(ihit);
657                   Int_t celldataPid   = pmdcl->GetClusCellPid(ihit);
658                   Float_t celldataAdc = pmdcl->GetClusCellAdc(ihit);
659                   AddRecHit(celldataX, celldataY, celldataTr, celldataPid, celldataAdc);
660                 }
661               branch2->Fill();
662               ResetRechit();
663
664             }
665           pmdcont->Delete();
666
667           branch1->Fill();
668           ResetRecpoint();
669
670
671         } // smn
672
673       for (Int_t i=0; i<iSMN; i++)
674         {
675           for (Int_t j=0; j<kRow; j++) delete [] precpvADC[i][j];
676         }
677       for (Int_t i=0; i<iSMN; i++) delete [] precpvADC[i];
678       delete [] precpvADC;
679
680     } // DDL Loop
681
682   
683   ResetCellADC();
684   
685   //   delete the pointers
686   delete pmdclust;
687   delete pmdcont;
688 }
689 // ------------------------------------------------------------------------- //
690 void AliPMDClusterFinder::AddRecPoint(Int_t idet,Int_t ismn,Float_t *clusdata)
691 {
692   // Add Reconstructed points
693   //
694   TClonesArray &lrecpoints = *fRecpoints;
695   AliPMDrecpoint1 *newrecpoint;
696   newrecpoint = new AliPMDrecpoint1(idet, ismn, clusdata);
697   new(lrecpoints[fNpoint++]) AliPMDrecpoint1(newrecpoint);
698   delete newrecpoint;
699 }
700 // ------------------------------------------------------------------------- //
701 void AliPMDClusterFinder::AddRecHit(Int_t celldataX,Int_t celldataY,
702                                     Int_t celldataTr, Int_t celldataPid,
703                                     Float_t celldataAdc)
704 {
705   // Add associated cell hits to the Reconstructed points
706   //
707   TClonesArray &lrechits = *fRechits;
708   AliPMDrechit *newrechit;
709   newrechit = new AliPMDrechit(celldataX, celldataY, celldataTr, celldataPid, celldataAdc);
710   new(lrechits[fNhit++]) AliPMDrechit(newrechit);
711   delete newrechit;
712 }
713 // ------------------------------------------------------------------------- //
714 void AliPMDClusterFinder::ResetCellADC()
715 {
716   // Reset the individual cell ADC value to zero
717   //
718   for(Int_t irow = 0; irow < fgkRow; irow++)
719     {
720       for(Int_t icol = 0; icol < fgkCol; icol++)
721         {
722           fCellTrack[irow][icol] = -1;
723           fCellPid[irow][icol]   = -1;
724           fCellADC[irow][icol]   = 0.;
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 AliPMDCalibData* AliPMDClusterFinder::GetCalibGain() const
774 {
775   // The run number will be centralized in AliCDBManager,
776   // you don't need to set it here!
777   // Added by ZA
778   AliCDBEntry  *entry = AliCDBManager::Instance()->Get("PMD/Calib/Gain");
779   
780   if(!entry)  AliFatal("Calibration object retrieval failed! ");
781   
782   AliPMDCalibData *calibdata=0;
783   if (entry) calibdata = (AliPMDCalibData*) entry->GetObject();
784   
785   if (!calibdata)  AliFatal("No calibration data from calibration database !");
786   
787   return calibdata;
788 }
789 // ------------------------------------------------------------------------- //
790 AliPMDPedestal* AliPMDClusterFinder::GetCalibPed() 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/Ped");
795   
796   if(!entry) AliFatal("Pedestal object retrieval failed!");
797     
798   AliPMDPedestal *pedestal = 0;
799   if (entry) pedestal = (AliPMDPedestal*) entry->GetObject();
800   
801   if (!pedestal)  AliFatal("No pedestal data from pedestal database !");
802   
803   return pedestal;
804 }
805 //--------------------------------------------------------------------//
806 AliPMDHotData* AliPMDClusterFinder::GetCalibHot() const
807 {
808   // The run number will be centralized in AliCDBManager,
809   // you don't need to set it here!
810   AliCDBEntry  *entry = AliCDBManager::Instance()->Get("PMD/Calib/Hot");
811   
812   if(!entry) AliFatal("HotData object retrieval failed!");
813   
814   AliPMDHotData *hot = 0;
815   if (entry) hot = (AliPMDHotData*) entry->GetObject();
816   
817   if (!hot)  AliFatal("No hot data from  database !");
818   
819   return hot;
820 }
821 //--------------------------------------------------------------------//
822 AliPMDNoiseCut* AliPMDClusterFinder::GetNoiseCut() const
823 {
824   // The run number will be centralized in AliCDBManager,
825   // you don't need to set it here!
826   AliCDBEntry  *entry = AliCDBManager::Instance()->Get("PMD/Calib/NoiseCut");
827   
828   if(!entry) AliFatal("Noisecut object retrieval failed!");
829   
830   AliPMDNoiseCut *ncut = 0;
831   if (entry) ncut = (AliPMDNoiseCut*) entry->GetObject();
832   
833   if (!ncut)  AliFatal("No noise cut data from  database !");
834   
835   return ncut;
836 }
837 //--------------------------------------------------------------------//
838 AliPMDddlinfoData* AliPMDClusterFinder::GetDdlinfoData() const
839 {
840   // The run number will be centralized in AliCDBManager,
841   // you don't need to set it here!
842   AliCDBEntry  *entry = AliCDBManager::Instance()->Get("PMD/Calib/Ddlinfo");
843   
844   if(!entry) AliFatal("ddlinfo object retrieval failed!");
845   
846   AliPMDddlinfoData *ddlinfo = 0;
847   if (entry) ddlinfo = (AliPMDddlinfoData*) entry->GetObject();
848   
849   if (!ddlinfo)  AliFatal("No ddl info data from  database !");
850   
851   return ddlinfo;
852 }
853