1 /***************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
16 //-----------------------------------------------------//
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) //
23 //-----------------------------------------------------//
25 #include <Riostream.h>
27 #include <TObjArray.h>
28 #include <TClonesArray.h>
31 #include "AliRunLoader.h"
32 #include "AliLoader.h"
33 #include "AliRawReader.h"
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"
48 #include "AliCDBManager.h"
49 #include "AliCDBEntry.h"
53 ClassImp(AliPMDClusterFinder)
55 AliPMDClusterFinder::AliPMDClusterFinder():
58 fCalibGain(GetCalibGain()),
59 fCalibPed(GetCalibPed()),
62 fDigits(new TClonesArray("AliPMDdigit", 1000)),
63 fRecpoints(new TClonesArray("AliPMDrecpoint1", 1000)),
64 fRechits(new TClonesArray("AliPMDrechit", 1000)),
74 // ------------------------------------------------------------------------- //
75 AliPMDClusterFinder::AliPMDClusterFinder(AliRunLoader* runLoader):
76 fRunLoader(runLoader),
77 fPMDLoader(runLoader->GetLoader("PMDLoader")),
78 fCalibGain(GetCalibGain()),
79 fCalibPed(GetCalibPed()),
82 fDigits(new TClonesArray("AliPMDdigit", 1000)),
83 fRecpoints(new TClonesArray("AliPMDrecpoint1", 1000)),
84 fRechits(new TClonesArray("AliPMDrechit", 1000)),
94 // ------------------------------------------------------------------------- //
95 AliPMDClusterFinder::AliPMDClusterFinder(const AliPMDClusterFinder & finder):
99 fCalibGain(GetCalibGain()),
100 fCalibPed(GetCalibPed()),
112 AliError("Copy constructor not allowed");
114 // ------------------------------------------------------------------------- //
115 AliPMDClusterFinder &AliPMDClusterFinder::operator=(const AliPMDClusterFinder & /*finder*/)
118 AliError("Assignment Operator not allowed");
121 // ------------------------------------------------------------------------- //
122 AliPMDClusterFinder::~AliPMDClusterFinder()
133 fRecpoints->Delete();
144 // ------------------------------------------------------------------------- //
146 void AliPMDClusterFinder::Digits2RecPoints(Int_t ievt)
148 // Converts digits to recpoints after running clustering
149 // algorithm on CPV plane and PREshower plane
152 Int_t det = 0,smn = 0;
159 TObjArray *pmdcont = new TObjArray();
160 AliPMDClustering *pmdclust = new AliPMDClusteringV1();
162 pmdclust->SetEdepCut(fEcut);
164 fRunLoader->GetEvent(ievt);
167 fTreeD = fPMDLoader->TreeD();
170 AliFatal("AliPMDClusterFinder: Can not get TreeD");
173 AliPMDdigit *pmddigit;
174 TBranch *branch = fTreeD->GetBranch("PMDDigit");
175 branch->SetAddress(&fDigits);
179 fTreeR = fPMDLoader->TreeR();
182 fPMDLoader->MakeTree("R");
183 fTreeR = fPMDLoader->TreeR();
186 Int_t bufsize = 16000;
187 TBranch * branch1 = fTreeR->Branch("PMDRecpoint", &fRecpoints, bufsize);
188 TBranch * branch2 = fTreeR->Branch("PMDRechit", &fRechits, bufsize);
190 Int_t nmodules = (Int_t) fTreeD->GetEntries();
192 for (Int_t imodule = 0; imodule < nmodules; imodule++)
195 fTreeD->GetEntry(imodule);
196 Int_t nentries = fDigits->GetLast();
197 for (Int_t ient = 0; ient < nentries+1; ient++)
199 pmddigit = (AliPMDdigit*)fDigits->UncheckedAt(ient);
201 det = pmddigit->GetDetector();
202 smn = pmddigit->GetSMNumber();
203 xpos = pmddigit->GetRow();
204 ypos = pmddigit->GetColumn();
205 adc = pmddigit->GetADC();
208 Float_t gain = fCalibGain->GetGainFact(det,smn,xpos,ypos);
209 // printf("adc = %d gain = %f\n",adc,gain);
213 //Int_t trno = pmddigit->GetTrackNumber();
214 fCellADC[xpos][ypos] = (Double_t) adc;
219 pmdclust->DoClust(idet,ismn,fCellADC,pmdcont);
221 Int_t nentries1 = pmdcont->GetEntries();
223 AliDebug(1,Form("Total number of clusters/module = %d",nentries1));
225 for (Int_t ient1 = 0; ient1 < nentries1; ient1++)
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();
237 AddRecPoint(idet,ismn,clusdata);
239 Int_t ncell = (Int_t) clusdata[3];
240 for(Int_t ihit = 0; ihit < ncell; ihit++)
242 Int_t celldataX = pmdcl->GetClusCellX(ihit);
243 Int_t celldataY = pmdcl->GetClusCellY(ihit);
244 AddRecHit(celldataX, celldataY);
257 fPMDLoader = fRunLoader->GetLoader("PMDLoader");
258 fPMDLoader->WriteRecPoints("OVERWRITE");
260 // delete the pointers
265 // ------------------------------------------------------------------------- //
267 void AliPMDClusterFinder::Digits2RecPoints(TTree *digitsTree,
270 // Converts digits to recpoints after running clustering
271 // algorithm on CPV plane and PREshower plane
274 Int_t det = 0,smn = 0;
281 TObjArray *pmdcont = new TObjArray();
282 AliPMDClustering *pmdclust = new AliPMDClusteringV1();
284 pmdclust->SetEdepCut(fEcut);
286 AliPMDdigit *pmddigit;
287 TBranch *branch = digitsTree->GetBranch("PMDDigit");
288 branch->SetAddress(&fDigits);
292 Int_t bufsize = 16000;
293 TBranch * branch1 = clustersTree->Branch("PMDRecpoint", &fRecpoints, bufsize);
294 TBranch * branch2 = clustersTree->Branch("PMDRechit", &fRechits, bufsize);
296 Int_t nmodules = (Int_t) digitsTree->GetEntries();
298 for (Int_t imodule = 0; imodule < nmodules; imodule++)
301 digitsTree->GetEntry(imodule);
302 Int_t nentries = fDigits->GetLast();
303 for (Int_t ient = 0; ient < nentries+1; ient++)
305 pmddigit = (AliPMDdigit*)fDigits->UncheckedAt(ient);
307 det = pmddigit->GetDetector();
308 smn = pmddigit->GetSMNumber();
309 xpos = pmddigit->GetRow();
310 ypos = pmddigit->GetColumn();
311 adc = pmddigit->GetADC();
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);
320 Float_t adc1 = adc - (pedmean + 3.0*pedrms);
323 Float_t gain = fCalibGain->GetGainFact(det,smn,xpos,ypos);
324 // printf("adc = %d gain = %f\n",adc,gain);
328 //Int_t trno = pmddigit->GetTrackNumber();
329 fCellADC[xpos][ypos] = (Double_t) adc;
334 pmdclust->DoClust(idet,ismn,fCellADC,pmdcont);
336 Int_t nentries1 = pmdcont->GetEntries();
338 AliDebug(1,Form("Total number of clusters/module = %d",nentries1));
340 for (Int_t ient1 = 0; ient1 < nentries1; ient1++)
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();
352 AddRecPoint(idet,ismn,clusdata);
354 Int_t ncell = (Int_t) clusdata[3];
355 for(Int_t ihit = 0; ihit < ncell; ihit++)
357 Int_t celldataX = pmdcl->GetClusCellX(ihit);
358 Int_t celldataY = pmdcl->GetClusCellY(ihit);
359 AddRecHit(celldataX, celldataY);
373 // delete the pointers
378 // ------------------------------------------------------------------------- //
380 void AliPMDClusterFinder::Digits2RecPoints(AliRawReader *rawReader,
383 // Converts RAW data to recpoints after running clustering
384 // algorithm on CPV and PREshower plane
386 // This method is called at the time of reconstruction
390 TObjArray pmdddlcont;
392 TObjArray *pmdcont = new TObjArray();
393 AliPMDClustering *pmdclust = new AliPMDClusteringV1();
395 pmdclust->SetEdepCut(fEcut);
399 Int_t bufsize = 16000;
400 TBranch *branch1 = clustersTree->Branch("PMDRecpoint", &fRecpoints, bufsize);
402 TBranch * branch2 = clustersTree->Branch("PMDRechit", &fRechits, bufsize);
404 const Int_t kDDL = AliDAQ::NumberOfDdls("PMD");
405 const Int_t kRow = 48;
406 const Int_t kCol = 96;
412 for (Int_t indexDDL = 0; indexDDL < kDDL; indexDDL++)
418 else if (indexDDL >= 4)
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++)
427 for (Int_t j=0; j<kRow; j++) precpvADC[i][j] = new int [kCol];
429 for (Int_t i = 0; i < iSMN; i++)
431 for (Int_t j = 0; j < kRow; j++)
433 for (Int_t k = 0; k < kCol; k++)
435 precpvADC[i][j][k] = 0;
441 AliPMDRawStream pmdinput(rawReader);
443 rawReader->Select("PMD", indexDDL, indexDDL);
445 pmdinput.DdlData(indexDDL,&pmdddlcont);
448 Int_t ientries = pmdddlcont.GetEntries();
449 for (Int_t ient = 0; ient < ientries; ient++)
451 AliPMDddldata *pmdddl = (AliPMDddldata*)pmdddlcont.UncheckedAt(ient);
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();
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;
467 //printf("%f %f\n",pedmean, pedrms);
469 // Float_t sig1 = (Float_t) sig;
470 Float_t sig1 = (Float_t) sig - (pedmean + 3.0*pedrms);
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);
480 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
482 indexsmn = smn - indexDDL * 6;
484 else if (indexDDL == 4)
487 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
493 else if (smn >= 18 && smn < 24)
498 else if (indexDDL == 5)
501 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
503 if (smn >= 6 && smn < 12)
507 else if (smn >= 12 && smn < 18)
512 precpvADC[indexsmn][row][col] = sig;
518 for (indexsmn = 0; indexsmn < iSMN; indexsmn++)
521 for (Int_t irow = 0; irow < kRow; irow++)
523 for (Int_t icol = 0; icol < kCol; icol++)
525 fCellADC[irow][icol] =
526 (Double_t) precpvADC[indexsmn][irow][icol];
532 ismn = indexsmn + indexDDL * 6;
535 else if (indexDDL == 4)
541 else if (indexsmn >= 6 && indexsmn < 12)
543 ismn = indexsmn + 12;
547 else if (indexDDL == 5)
553 else if (indexsmn >= 6 && indexsmn < 12)
560 pmdclust->DoClust(idet,ismn,fCellADC,pmdcont);
561 Int_t nentries1 = pmdcont->GetEntries();
563 AliDebug(1,Form("Total number of clusters/module = %d",nentries1));
565 for (Int_t ient1 = 0; ient1 < nentries1; ient1++)
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();
578 AddRecPoint(idet,ismn,clusdata);
580 Int_t ncell = (Int_t) clusdata[3];
581 for(Int_t ihit = 0; ihit < ncell; ihit++)
583 Int_t celldataX = pmdcl->GetClusCellX(ihit);
584 Int_t celldataY = pmdcl->GetClusCellY(ihit);
585 AddRecHit(celldataX, celldataY);
599 for (Int_t i=0; i<iSMN; i++)
601 for (Int_t j=0; j<kRow; j++) delete [] precpvADC[i][j];
603 for (Int_t i=0; i<iSMN; i++) delete [] precpvADC[i];
609 // delete the pointers
614 // ------------------------------------------------------------------------- //
616 void AliPMDClusterFinder::Digits2RecPoints(Int_t ievt, AliRawReader *rawReader)
618 // Converts RAW data to recpoints after running clustering
619 // algorithm on CPV and PREshower plane
623 TObjArray pmdddlcont;
624 TObjArray *pmdcont = new TObjArray();
626 AliPMDClustering *pmdclust = new AliPMDClusteringV1();
628 pmdclust->SetEdepCut(fEcut);
630 fRunLoader->GetEvent(ievt);
634 fTreeR = fPMDLoader->TreeR();
637 fPMDLoader->MakeTree("R");
638 fTreeR = fPMDLoader->TreeR();
640 Int_t bufsize = 16000;
641 TBranch *branch1 = fTreeR->Branch("PMDRecpoint", &fRecpoints, bufsize);
642 TBranch *branch2 = fTreeR->Branch("PMDRechit", &fRechits, bufsize);
644 const Int_t kDDL = AliDAQ::NumberOfDdls("PMD");
645 const Int_t kRow = 48;
646 const Int_t kCol = 96;
651 for (Int_t indexDDL = 0; indexDDL < kDDL; indexDDL++)
657 else if (indexDDL >= 4)
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++)
666 for (Int_t j=0; j<kRow; j++) precpvADC[i][j] = new int [kCol];
668 for (Int_t i = 0; i < iSMN; i++)
670 for (Int_t j = 0; j < kRow; j++)
672 for (Int_t k = 0; k < kCol; k++)
674 precpvADC[i][j][k] = 0;
680 rawReader->Select("PMD", indexDDL, indexDDL);
682 AliPMDRawStream pmdinput(rawReader);
683 pmdinput.DdlData(indexDDL,&pmdddlcont);
686 Int_t ientries = pmdddlcont.GetEntries();
687 for (Int_t ient = 0; ient < ientries; ient++)
689 AliPMDddldata *pmdddl = (AliPMDddldata*)pmdddlcont.UncheckedAt(ient);
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();
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;
705 //printf("%f %f\n",pedmean, pedrms);
707 //Float_t sig1 = (Float_t) sig;
708 Float_t sig1 = (Float_t) sig - (pedmean + 3.0*pedrms);
710 Float_t gain = fCalibGain->GetGainFact(det,smn,row,col);
712 //printf("sig = %d gain = %f\n",sig,gain);
713 sig = (Int_t) (sig1*gain);
719 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
721 indexsmn = smn - indexDDL * 6;
723 else if (indexDDL == 4)
726 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
732 else if (smn >= 18 && smn < 24)
737 else if (indexDDL == 5)
740 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
742 if (smn >= 6 && smn < 12)
746 else if (smn >= 12 && smn < 18)
751 precpvADC[indexsmn][row][col] = sig;
758 for (indexsmn = 0; indexsmn < iSMN; indexsmn++)
761 for (Int_t irow = 0; irow < kRow; irow++)
763 for (Int_t icol = 0; icol < kCol; icol++)
765 fCellADC[irow][icol] =
766 (Double_t) precpvADC[indexsmn][irow][icol];
773 ismn = indexsmn + indexDDL * 6;
776 else if (indexDDL == 4)
782 else if (indexsmn >= 6 && indexsmn < 12)
784 ismn = indexsmn + 12;
788 else if (indexDDL == 5)
794 else if (indexsmn >= 6 && indexsmn < 12)
801 pmdclust->DoClust(idet,ismn,fCellADC,pmdcont);
802 Int_t nentries1 = pmdcont->GetEntries();
804 AliDebug(1,Form("Total number of clusters/module = %d",nentries1));
806 for (Int_t ient1 = 0; ient1 < nentries1; ient1++)
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();
819 AddRecPoint(idet,ismn,clusdata);
821 Int_t ncell = (Int_t) clusdata[3];
822 for(Int_t ihit = 0; ihit < ncell; ihit++)
824 Int_t celldataX = pmdcl->GetClusCellX(ihit);
825 Int_t celldataY = pmdcl->GetClusCellY(ihit);
826 AddRecHit(celldataX, celldataY);
840 for (Int_t i=0; i<iSMN; i++)
842 for (Int_t j=0; j<kRow; j++) delete [] precpvADC[i][j];
844 for (Int_t i=0; i<iSMN; i++) delete [] precpvADC[i];
850 fPMDLoader = fRunLoader->GetLoader("PMDLoader");
851 fPMDLoader->WriteRecPoints("OVERWRITE");
853 // delete the pointers
858 // ------------------------------------------------------------------------- //
859 void AliPMDClusterFinder::SetCellEdepCut(Float_t ecut)
863 // ------------------------------------------------------------------------- //
864 void AliPMDClusterFinder::AddRecPoint(Int_t idet,Int_t ismn,Float_t *clusdata)
866 // Add Reconstructed points
868 TClonesArray &lrecpoints = *fRecpoints;
869 AliPMDrecpoint1 *newrecpoint;
870 newrecpoint = new AliPMDrecpoint1(idet, ismn, clusdata);
871 new(lrecpoints[fNpoint++]) AliPMDrecpoint1(newrecpoint);
874 // ------------------------------------------------------------------------- //
875 void AliPMDClusterFinder::AddRecHit(Int_t celldataX,Int_t celldataY)
877 // Add associated cell hits to the Reconstructed points
879 TClonesArray &lrechits = *fRechits;
880 AliPMDrechit *newrechit;
881 newrechit = new AliPMDrechit(celldataX, celldataY);
882 new(lrechits[fNhit++]) AliPMDrechit(newrechit);
885 // ------------------------------------------------------------------------- //
886 void AliPMDClusterFinder::ResetCellADC()
888 // Reset the individual cell ADC value to zero
890 for(Int_t irow = 0; irow < fgkRow; irow++)
892 for(Int_t icol = 0; icol < fgkCol; icol++)
894 fCellADC[irow][icol] = 0.;
898 // ------------------------------------------------------------------------- //
900 void AliPMDClusterFinder::ResetRecpoint()
902 // Clear the list of reconstructed points
904 if (fRecpoints) fRecpoints->Clear();
906 // ------------------------------------------------------------------------- //
907 void AliPMDClusterFinder::ResetRechit()
909 // Clear the list of reconstructed points
911 if (fRechits) fRechits->Clear();
913 // ------------------------------------------------------------------------- //
914 void AliPMDClusterFinder::Load()
916 // Load all the *.root files
918 fPMDLoader->LoadDigits("READ");
919 fPMDLoader->LoadRecPoints("recreate");
921 // ------------------------------------------------------------------------- //
922 void AliPMDClusterFinder::LoadClusters()
924 // Load all the *.root files
926 fPMDLoader->LoadRecPoints("recreate");
928 // ------------------------------------------------------------------------- //
929 void AliPMDClusterFinder::UnLoad()
931 // Unload all the *.root files
933 fPMDLoader->UnloadDigits();
934 fPMDLoader->UnloadRecPoints();
936 // ------------------------------------------------------------------------- //
937 void AliPMDClusterFinder::UnLoadClusters()
939 // Unload all the *.root files
941 fPMDLoader->UnloadRecPoints();
943 // ------------------------------------------------------------------------- //
945 AliPMDCalibData* AliPMDClusterFinder::GetCalibGain() const
947 // The run number will be centralized in AliCDBManager,
948 // you don't need to set it here!
950 AliCDBEntry *entry = AliCDBManager::Instance()->Get("PMD/Calib/Gain");
952 if(!entry) AliFatal("Calibration object retrieval failed! ");
954 AliPMDCalibData *calibdata=0;
955 if (entry) calibdata = (AliPMDCalibData*) entry->GetObject();
957 if (!calibdata) AliFatal("No calibration data from calibration database !");
962 // ------------------------------------------------------------------------- //
964 AliPMDPedestal* AliPMDClusterFinder::GetCalibPed() const
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");
970 if(!entry) AliFatal("Pedestal object retrieval failed!");
972 AliPMDPedestal *pedestal = 0;
973 if (entry) pedestal = (AliPMDPedestal*) entry->GetObject();
975 if (!pedestal) AliFatal("No pedestal data from pedestal database !");