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()
138 // ------------------------------------------------------------------------- //
140 void AliPMDClusterFinder::Digits2RecPoints(Int_t ievt)
142 // Converts digits to recpoints after running clustering
143 // algorithm on CPV plane and PREshower plane
146 Int_t det = 0,smn = 0;
153 TObjArray *pmdcont = new TObjArray();
154 AliPMDClustering *pmdclust = new AliPMDClusteringV1();
156 pmdclust->SetEdepCut(fEcut);
158 fRunLoader->GetEvent(ievt);
161 fTreeD = fPMDLoader->TreeD();
164 AliFatal("AliPMDClusterFinder: Can not get TreeD");
167 AliPMDdigit *pmddigit;
168 TBranch *branch = fTreeD->GetBranch("PMDDigit");
169 branch->SetAddress(&fDigits);
173 fTreeR = fPMDLoader->TreeR();
176 fPMDLoader->MakeTree("R");
177 fTreeR = fPMDLoader->TreeR();
180 Int_t bufsize = 16000;
181 TBranch * branch1 = fTreeR->Branch("PMDRecpoint", &fRecpoints, bufsize);
182 TBranch * branch2 = fTreeR->Branch("PMDRechit", &fRechits, bufsize);
184 Int_t nmodules = (Int_t) fTreeD->GetEntries();
186 for (Int_t imodule = 0; imodule < nmodules; imodule++)
189 fTreeD->GetEntry(imodule);
190 Int_t nentries = fDigits->GetLast();
191 for (Int_t ient = 0; ient < nentries+1; ient++)
193 pmddigit = (AliPMDdigit*)fDigits->UncheckedAt(ient);
195 det = pmddigit->GetDetector();
196 smn = pmddigit->GetSMNumber();
197 xpos = pmddigit->GetRow();
198 ypos = pmddigit->GetColumn();
199 adc = pmddigit->GetADC();
202 Float_t gain = fCalibGain->GetGainFact(det,smn,xpos,ypos);
203 // printf("adc = %d gain = %f\n",adc,gain);
207 //Int_t trno = pmddigit->GetTrackNumber();
208 fCellADC[xpos][ypos] = (Double_t) adc;
213 pmdclust->DoClust(idet,ismn,fCellADC,pmdcont);
215 Int_t nentries1 = pmdcont->GetEntries();
217 AliDebug(1,Form("Total number of clusters/module = %d",nentries1));
219 for (Int_t ient1 = 0; ient1 < nentries1; ient1++)
221 AliPMDcluster *pmdcl = (AliPMDcluster*)pmdcont->UncheckedAt(ient1);
222 idet = pmdcl->GetDetector();
223 ismn = pmdcl->GetSMN();
224 clusdata[0] = pmdcl->GetClusX();
225 clusdata[1] = pmdcl->GetClusY();
226 clusdata[2] = pmdcl->GetClusADC();
227 clusdata[3] = pmdcl->GetClusCells();
228 clusdata[4] = pmdcl->GetClusSigmaX();
229 clusdata[5] = pmdcl->GetClusSigmaY();
231 AddRecPoint(idet,ismn,clusdata);
233 Int_t ncell = (Int_t) clusdata[3];
234 for(Int_t ihit = 0; ihit < ncell; ihit++)
236 Int_t celldataX = pmdcl->GetClusCellX(ihit);
237 Int_t celldataY = pmdcl->GetClusCellY(ihit);
238 AddRecHit(celldataX, celldataY);
251 fPMDLoader = fRunLoader->GetLoader("PMDLoader");
252 fPMDLoader->WriteRecPoints("OVERWRITE");
254 // delete the pointers
259 // ------------------------------------------------------------------------- //
261 void AliPMDClusterFinder::Digits2RecPoints(TTree *digitsTree,
264 // Converts digits to recpoints after running clustering
265 // algorithm on CPV plane and PREshower plane
268 Int_t det = 0,smn = 0;
275 TObjArray *pmdcont = new TObjArray();
276 AliPMDClustering *pmdclust = new AliPMDClusteringV1();
278 pmdclust->SetEdepCut(fEcut);
280 AliPMDdigit *pmddigit;
281 TBranch *branch = digitsTree->GetBranch("PMDDigit");
282 branch->SetAddress(&fDigits);
286 Int_t bufsize = 16000;
287 TBranch * branch1 = clustersTree->Branch("PMDRecpoint", &fRecpoints, bufsize);
288 TBranch * branch2 = clustersTree->Branch("PMDRechit", &fRechits, bufsize);
290 Int_t nmodules = (Int_t) digitsTree->GetEntries();
292 for (Int_t imodule = 0; imodule < nmodules; imodule++)
295 digitsTree->GetEntry(imodule);
296 Int_t nentries = fDigits->GetLast();
297 for (Int_t ient = 0; ient < nentries+1; ient++)
299 pmddigit = (AliPMDdigit*)fDigits->UncheckedAt(ient);
301 det = pmddigit->GetDetector();
302 smn = pmddigit->GetSMNumber();
303 xpos = pmddigit->GetRow();
304 ypos = pmddigit->GetColumn();
305 adc = pmddigit->GetADC();
307 // Pedestal Subtraction
308 Int_t pedmeanrms = fCalibPed->GetPedMeanRms(det,smn,xpos,ypos);
309 Int_t pedrms1 = (Int_t) pedmeanrms%1000;
310 Float_t pedrms = (Float_t)pedrms1/10.;
311 Float_t pedmean = (Float_t) (pedmeanrms - pedrms1)/1000.0;
312 //printf("%f %f\n",pedmean, pedrms);
314 Float_t adc1 = adc - (pedmean + 3.0*pedrms);
317 Float_t gain = fCalibGain->GetGainFact(det,smn,xpos,ypos);
318 // printf("adc = %d gain = %f\n",adc,gain);
322 //Int_t trno = pmddigit->GetTrackNumber();
323 fCellADC[xpos][ypos] = (Double_t) adc;
328 pmdclust->DoClust(idet,ismn,fCellADC,pmdcont);
330 Int_t nentries1 = pmdcont->GetEntries();
332 AliDebug(1,Form("Total number of clusters/module = %d",nentries1));
334 for (Int_t ient1 = 0; ient1 < nentries1; ient1++)
336 AliPMDcluster *pmdcl = (AliPMDcluster*)pmdcont->UncheckedAt(ient1);
337 idet = pmdcl->GetDetector();
338 ismn = pmdcl->GetSMN();
339 clusdata[0] = pmdcl->GetClusX();
340 clusdata[1] = pmdcl->GetClusY();
341 clusdata[2] = pmdcl->GetClusADC();
342 clusdata[3] = pmdcl->GetClusCells();
343 clusdata[4] = pmdcl->GetClusSigmaX();
344 clusdata[5] = pmdcl->GetClusSigmaY();
346 AddRecPoint(idet,ismn,clusdata);
348 Int_t ncell = (Int_t) clusdata[3];
349 for(Int_t ihit = 0; ihit < ncell; ihit++)
351 Int_t celldataX = pmdcl->GetClusCellX(ihit);
352 Int_t celldataY = pmdcl->GetClusCellY(ihit);
353 AddRecHit(celldataX, celldataY);
367 // delete the pointers
372 // ------------------------------------------------------------------------- //
374 void AliPMDClusterFinder::Digits2RecPoints(AliRawReader *rawReader,
377 // Converts RAW data to recpoints after running clustering
378 // algorithm on CPV and PREshower plane
380 // This method is called at the time of reconstruction
384 TObjArray pmdddlcont;
386 TObjArray *pmdcont = new TObjArray();
387 AliPMDClustering *pmdclust = new AliPMDClusteringV1();
389 pmdclust->SetEdepCut(fEcut);
393 Int_t bufsize = 16000;
394 TBranch *branch1 = clustersTree->Branch("PMDRecpoint", &fRecpoints, bufsize);
396 TBranch * branch2 = clustersTree->Branch("PMDRechit", &fRechits, bufsize);
398 const Int_t kRow = 48;
399 const Int_t kCol = 96;
405 AliPMDRawStream pmdinput(rawReader);
407 while ((indexDDL = pmdinput.DdlData(&pmdddlcont)) >=0)
413 else if (indexDDL >= 4)
418 precpvADC = new int **[iSMN];
419 for (Int_t i=0; i<iSMN; i++) precpvADC[i] = new int *[kRow];
420 for (Int_t i=0; i<iSMN;i++)
422 for (Int_t j=0; j<kRow; j++) precpvADC[i][j] = new int [kCol];
424 for (Int_t i = 0; i < iSMN; i++)
426 for (Int_t j = 0; j < kRow; j++)
428 for (Int_t k = 0; k < kCol; k++)
430 precpvADC[i][j][k] = 0;
437 Int_t ientries = pmdddlcont.GetEntries();
438 for (Int_t ient = 0; ient < ientries; ient++)
440 AliPMDddldata *pmdddl = (AliPMDddldata*)pmdddlcont.UncheckedAt(ient);
442 Int_t det = pmdddl->GetDetector();
443 Int_t smn = pmdddl->GetSMN();
444 //Int_t mcm = pmdddl->GetMCM();
445 //Int_t chno = pmdddl->GetChannel();
446 Int_t row = pmdddl->GetRow();
447 Int_t col = pmdddl->GetColumn();
448 Int_t sig = pmdddl->GetSignal();
450 // Pedestal Subtraction
451 Int_t pedmeanrms = fCalibPed->GetPedMeanRms(det,smn,row,col);
452 Int_t pedrms1 = (Int_t) pedmeanrms%1000;
453 Float_t pedrms = (Float_t)pedrms1/10.;
454 Float_t pedmean = (Float_t) (pedmeanrms - pedrms1)/1000.0;
456 //printf("%f %f\n",pedmean, pedrms);
458 // Float_t sig1 = (Float_t) sig;
459 Float_t sig1 = (Float_t) sig - (pedmean + 3.0*pedrms);
462 Float_t gain = fCalibGain->GetGainFact(det,smn,row,col);
463 //printf("sig = %d gain = %f\n",sig,gain);
464 sig = (Int_t) (sig1*gain);
469 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
471 indexsmn = smn - indexDDL * 6;
473 else if (indexDDL == 4)
476 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
482 else if (smn >= 18 && smn < 24)
487 else if (indexDDL == 5)
490 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
492 if (smn >= 6 && smn < 12)
496 else if (smn >= 12 && smn < 18)
501 precpvADC[indexsmn][row][col] = sig;
504 //pmdddlcont.Clear();
508 for (indexsmn = 0; indexsmn < iSMN; indexsmn++)
511 for (Int_t irow = 0; irow < kRow; irow++)
513 for (Int_t icol = 0; icol < kCol; icol++)
515 fCellADC[irow][icol] =
516 (Double_t) precpvADC[indexsmn][irow][icol];
522 ismn = indexsmn + indexDDL * 6;
525 else if (indexDDL == 4)
531 else if (indexsmn >= 6 && indexsmn < 12)
533 ismn = indexsmn + 12;
537 else if (indexDDL == 5)
543 else if (indexsmn >= 6 && indexsmn < 12)
550 pmdclust->DoClust(idet,ismn,fCellADC,pmdcont);
551 Int_t nentries1 = pmdcont->GetEntries();
553 AliDebug(1,Form("Total number of clusters/module = %d",nentries1));
555 for (Int_t ient1 = 0; ient1 < nentries1; ient1++)
557 AliPMDcluster *pmdcl =
558 (AliPMDcluster*)pmdcont->UncheckedAt(ient1);
559 idet = pmdcl->GetDetector();
560 ismn = pmdcl->GetSMN();
561 clusdata[0] = pmdcl->GetClusX();
562 clusdata[1] = pmdcl->GetClusY();
563 clusdata[2] = pmdcl->GetClusADC();
564 clusdata[3] = pmdcl->GetClusCells();
565 clusdata[4] = pmdcl->GetClusSigmaX();
566 clusdata[5] = pmdcl->GetClusSigmaY();
568 AddRecPoint(idet,ismn,clusdata);
570 Int_t ncell = (Int_t) clusdata[3];
571 for(Int_t ihit = 0; ihit < ncell; ihit++)
573 Int_t celldataX = pmdcl->GetClusCellX(ihit);
574 Int_t celldataY = pmdcl->GetClusCellY(ihit);
575 AddRecHit(celldataX, celldataY);
589 for (Int_t i=0; i<iSMN; i++)
591 for (Int_t j=0; j<kRow; j++) delete [] precpvADC[i][j];
593 for (Int_t i=0; i<iSMN; i++) delete [] precpvADC[i];
600 // delete the pointers
605 // ------------------------------------------------------------------------- //
607 void AliPMDClusterFinder::Digits2RecPoints(Int_t ievt, AliRawReader *rawReader)
609 // Converts RAW data to recpoints after running clustering
610 // algorithm on CPV and PREshower plane
614 TObjArray pmdddlcont;
615 TObjArray *pmdcont = new TObjArray();
617 AliPMDClustering *pmdclust = new AliPMDClusteringV1();
619 pmdclust->SetEdepCut(fEcut);
621 fRunLoader->GetEvent(ievt);
625 fTreeR = fPMDLoader->TreeR();
628 fPMDLoader->MakeTree("R");
629 fTreeR = fPMDLoader->TreeR();
631 Int_t bufsize = 16000;
632 TBranch *branch1 = fTreeR->Branch("PMDRecpoint", &fRecpoints, bufsize);
633 TBranch *branch2 = fTreeR->Branch("PMDRechit", &fRechits, bufsize);
635 const Int_t kRow = 48;
636 const Int_t kCol = 96;
641 AliPMDRawStream pmdinput(rawReader);
644 while ((indexDDL = pmdinput.DdlData(&pmdddlcont)) >=0) {
650 else if (indexDDL >= 4)
655 precpvADC = new int **[iSMN];
656 for (Int_t i=0; i<iSMN; i++) precpvADC[i] = new int *[kRow];
657 for (Int_t i=0; i<iSMN;i++)
659 for (Int_t j=0; j<kRow; j++) precpvADC[i][j] = new int [kCol];
661 for (Int_t i = 0; i < iSMN; i++)
663 for (Int_t j = 0; j < kRow; j++)
665 for (Int_t k = 0; k < kCol; k++)
667 precpvADC[i][j][k] = 0;
675 Int_t ientries = pmdddlcont.GetEntries();
676 for (Int_t ient = 0; ient < ientries; ient++)
678 AliPMDddldata *pmdddl = (AliPMDddldata*)pmdddlcont.UncheckedAt(ient);
680 Int_t det = pmdddl->GetDetector();
681 Int_t smn = pmdddl->GetSMN();
682 //Int_t mcm = pmdddl->GetMCM();
683 //Int_t chno = pmdddl->GetChannel();
684 Int_t row = pmdddl->GetRow();
685 Int_t col = pmdddl->GetColumn();
686 Int_t sig = pmdddl->GetSignal();
688 // Pedestal Subtraction
689 Int_t pedmeanrms = fCalibPed->GetPedMeanRms(det,smn,row,col);
690 Int_t pedrms1 = (Int_t) pedmeanrms%1000;
691 Float_t pedrms = (Float_t)pedrms1/10.;
692 Float_t pedmean = (Float_t) (pedmeanrms - pedrms1)/1000.0;
694 //printf("%f %f\n",pedmean, pedrms);
696 //Float_t sig1 = (Float_t) sig;
697 Float_t sig1 = (Float_t) sig - (pedmean + 3.0*pedrms);
699 Float_t gain = fCalibGain->GetGainFact(det,smn,row,col);
701 //printf("sig = %d gain = %f\n",sig,gain);
702 sig = (Int_t) (sig1*gain);
708 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
710 indexsmn = smn - indexDDL * 6;
712 else if (indexDDL == 4)
715 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
721 else if (smn >= 18 && smn < 24)
726 else if (indexDDL == 5)
729 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
731 if (smn >= 6 && smn < 12)
735 else if (smn >= 12 && smn < 18)
740 precpvADC[indexsmn][row][col] = sig;
747 for (indexsmn = 0; indexsmn < iSMN; indexsmn++)
750 for (Int_t irow = 0; irow < kRow; irow++)
752 for (Int_t icol = 0; icol < kCol; icol++)
754 fCellADC[irow][icol] =
755 (Double_t) precpvADC[indexsmn][irow][icol];
762 ismn = indexsmn + indexDDL * 6;
765 else if (indexDDL == 4)
771 else if (indexsmn >= 6 && indexsmn < 12)
773 ismn = indexsmn + 12;
777 else if (indexDDL == 5)
783 else if (indexsmn >= 6 && indexsmn < 12)
790 pmdclust->DoClust(idet,ismn,fCellADC,pmdcont);
791 Int_t nentries1 = pmdcont->GetEntries();
793 AliDebug(1,Form("Total number of clusters/module = %d",nentries1));
795 for (Int_t ient1 = 0; ient1 < nentries1; ient1++)
797 AliPMDcluster *pmdcl =
798 (AliPMDcluster*)pmdcont->UncheckedAt(ient1);
799 idet = pmdcl->GetDetector();
800 ismn = pmdcl->GetSMN();
801 clusdata[0] = pmdcl->GetClusX();
802 clusdata[1] = pmdcl->GetClusY();
803 clusdata[2] = pmdcl->GetClusADC();
804 clusdata[3] = pmdcl->GetClusCells();
805 clusdata[4] = pmdcl->GetClusSigmaX();
806 clusdata[5] = pmdcl->GetClusSigmaY();
808 AddRecPoint(idet,ismn,clusdata);
810 Int_t ncell = (Int_t) clusdata[3];
811 for(Int_t ihit = 0; ihit < ncell; ihit++)
813 Int_t celldataX = pmdcl->GetClusCellX(ihit);
814 Int_t celldataY = pmdcl->GetClusCellY(ihit);
815 AddRecHit(celldataX, celldataY);
829 for (Int_t i=0; i<iSMN; i++)
831 for (Int_t j=0; j<kRow; j++) delete [] precpvADC[i][j];
833 for (Int_t i=0; i<iSMN; i++) delete [] precpvADC[i];
839 fPMDLoader = fRunLoader->GetLoader("PMDLoader");
840 fPMDLoader->WriteRecPoints("OVERWRITE");
842 // delete the pointers
847 // ------------------------------------------------------------------------- //
848 void AliPMDClusterFinder::SetCellEdepCut(Float_t ecut)
852 // ------------------------------------------------------------------------- //
853 void AliPMDClusterFinder::AddRecPoint(Int_t idet,Int_t ismn,Float_t *clusdata)
855 // Add Reconstructed points
857 TClonesArray &lrecpoints = *fRecpoints;
858 AliPMDrecpoint1 *newrecpoint;
859 newrecpoint = new AliPMDrecpoint1(idet, ismn, clusdata);
860 new(lrecpoints[fNpoint++]) AliPMDrecpoint1(newrecpoint);
863 // ------------------------------------------------------------------------- //
864 void AliPMDClusterFinder::AddRecHit(Int_t celldataX,Int_t celldataY)
866 // Add associated cell hits to the Reconstructed points
868 TClonesArray &lrechits = *fRechits;
869 AliPMDrechit *newrechit;
870 newrechit = new AliPMDrechit(celldataX, celldataY);
871 new(lrechits[fNhit++]) AliPMDrechit(newrechit);
874 // ------------------------------------------------------------------------- //
875 void AliPMDClusterFinder::ResetCellADC()
877 // Reset the individual cell ADC value to zero
879 for(Int_t irow = 0; irow < fgkRow; irow++)
881 for(Int_t icol = 0; icol < fgkCol; icol++)
883 fCellADC[irow][icol] = 0.;
887 // ------------------------------------------------------------------------- //
889 void AliPMDClusterFinder::ResetRecpoint()
891 // Clear the list of reconstructed points
893 if (fRecpoints) fRecpoints->Clear();
895 // ------------------------------------------------------------------------- //
896 void AliPMDClusterFinder::ResetRechit()
898 // Clear the list of reconstructed points
900 if (fRechits) fRechits->Clear();
902 // ------------------------------------------------------------------------- //
903 void AliPMDClusterFinder::Load()
905 // Load all the *.root files
907 fPMDLoader->LoadDigits("READ");
908 fPMDLoader->LoadRecPoints("recreate");
910 // ------------------------------------------------------------------------- //
911 void AliPMDClusterFinder::LoadClusters()
913 // Load all the *.root files
915 fPMDLoader->LoadRecPoints("recreate");
917 // ------------------------------------------------------------------------- //
918 void AliPMDClusterFinder::UnLoad()
920 // Unload all the *.root files
922 fPMDLoader->UnloadDigits();
923 fPMDLoader->UnloadRecPoints();
925 // ------------------------------------------------------------------------- //
926 void AliPMDClusterFinder::UnLoadClusters()
928 // Unload all the *.root files
930 fPMDLoader->UnloadRecPoints();
932 // ------------------------------------------------------------------------- //
934 AliPMDCalibData* AliPMDClusterFinder::GetCalibGain() const
936 // The run number will be centralized in AliCDBManager,
937 // you don't need to set it here!
939 AliCDBEntry *entry = AliCDBManager::Instance()->Get("PMD/Calib/Gain");
941 if(!entry) AliFatal("Calibration object retrieval failed! ");
943 AliPMDCalibData *calibdata=0;
944 if (entry) calibdata = (AliPMDCalibData*) entry->GetObject();
946 if (!calibdata) AliFatal("No calibration data from calibration database !");
951 // ------------------------------------------------------------------------- //
953 AliPMDPedestal* AliPMDClusterFinder::GetCalibPed() const
955 // The run number will be centralized in AliCDBManager,
956 // you don't need to set it here!
957 AliCDBEntry *entry = AliCDBManager::Instance()->Get("PMD/Calib/Ped");
959 if(!entry) AliFatal("Pedestal object retrieval failed!");
961 AliPMDPedestal *pedestal = 0;
962 if (entry) pedestal = (AliPMDPedestal*) entry->GetObject();
964 if (!pedestal) AliFatal("No pedestal data from pedestal database !");