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