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