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>
32 #include "AliRunLoader.h"
33 #include "AliLoader.h"
34 #include "AliRawReader.h"
36 #include "AliPMDdigit.h"
37 #include "AliPMDClusterFinder.h"
38 #include "AliPMDClustering.h"
39 #include "AliPMDClusteringV1.h"
40 #include "AliPMDcluster.h"
41 #include "AliPMDrecpoint1.h"
42 #include "AliPMDrechit.h"
43 #include "AliPMDRawStream.h"
44 #include "AliPMDCalibData.h"
45 #include "AliPMDPedestal.h"
46 #include "AliPMDddldata.h"
47 #include "AliPMDHotData.h"
48 #include "AliPMDNoiseCut.h"
49 #include "AliPMDddlinfoData.h"
50 #include "AliPMDRecoParam.h"
51 #include "AliPMDReconstructor.h"
54 #include "AliCDBManager.h"
55 #include "AliCDBEntry.h"
59 ClassImp(AliPMDClusterFinder)
61 AliPMDClusterFinder::AliPMDClusterFinder():
64 fCalibGain(GetCalibGain()),
65 fCalibPed(GetCalibPed()),
66 fCalibHot(GetCalibHot()),
67 fNoiseCut(GetNoiseCut()),
68 fDdlinfo(GetDdlinfoData()),
72 fDigits(new TClonesArray("AliPMDdigit", 1000)),
73 fRecpoints(new TClonesArray("AliPMDrecpoint1", 1000)),
74 fRechits(new TClonesArray("AliPMDrechit", 1000)),
83 // ------------------------------------------------------------------------- //
84 AliPMDClusterFinder::AliPMDClusterFinder(AliRunLoader* runLoader):
85 fRunLoader(runLoader),
86 fPMDLoader(runLoader->GetLoader("PMDLoader")),
87 fCalibGain(GetCalibGain()),
88 fCalibPed(GetCalibPed()),
89 fCalibHot(GetCalibHot()),
90 fNoiseCut(GetNoiseCut()),
91 fDdlinfo(GetDdlinfoData()),
95 fDigits(new TClonesArray("AliPMDdigit", 1000)),
96 fRecpoints(new TClonesArray("AliPMDrecpoint1", 1000)),
97 fRechits(new TClonesArray("AliPMDrechit", 1000)),
106 // ------------------------------------------------------------------------- //
107 AliPMDClusterFinder::AliPMDClusterFinder(const AliPMDClusterFinder & finder):
111 fCalibGain(GetCalibGain()),
112 fCalibPed(GetCalibPed()),
113 fCalibHot(GetCalibHot()),
114 fNoiseCut(GetNoiseCut()),
115 fDdlinfo(GetDdlinfoData()),
127 AliError("Copy constructor not allowed");
129 // ------------------------------------------------------------------------- //
130 AliPMDClusterFinder &AliPMDClusterFinder::operator=(const AliPMDClusterFinder & /*finder*/)
133 AliError("Assignment Operator not allowed");
136 // ------------------------------------------------------------------------- //
137 AliPMDClusterFinder::~AliPMDClusterFinder()
154 // ------------------------------------------------------------------------- //
156 void AliPMDClusterFinder::Digits2RecPoints(TTree *digitsTree,
159 // Converts digits to recpoints after running clustering
160 // algorithm on CPV plane and PREshower plane
162 // This algorithm is called during the reconstruction from digits
164 Int_t det = 0, smn = 0;
165 Int_t xpos = 0, ypos = 0;
169 Float_t clusdata[6] = {0.,0.,0.,0.,0.,0.};
171 AliPMDcluster *pmdcl = 0x0;
173 TObjArray *pmdcont = new TObjArray();
175 AliPMDClustering *pmdclust = new AliPMDClusteringV1();
177 // Fetch the reco param object
179 fRecoParam = AliPMDReconstructor::GetRecoParam();
180 if(fRecoParam == 0x0)
182 AliFatal("No Reco Param found for PMD!!!");
186 AliPMDdigit *pmddigit;
187 TBranch *branch = digitsTree->GetBranch("PMDDigit");
188 branch->SetAddress(&fDigits);
192 Int_t bufsize = 16000;
193 TBranch * branch1 = clustersTree->Branch("PMDRecpoint", &fRecpoints, bufsize);
194 TBranch * branch2 = clustersTree->Branch("PMDRechit", &fRechits, bufsize);
196 Int_t nmodules = (Int_t) digitsTree->GetEntries();
198 for (Int_t imodule = 0; imodule < nmodules; imodule++)
203 digitsTree->GetEntry(imodule);
204 Int_t nentries = fDigits->GetLast();
205 for (Int_t ient = 0; ient < nentries+1; ient++)
207 pmddigit = (AliPMDdigit*)fDigits->UncheckedAt(ient);
209 det = pmddigit->GetDetector();
210 smn = pmddigit->GetSMNumber();
211 xpos = pmddigit->GetRow();
212 ypos = pmddigit->GetColumn();
213 adc = pmddigit->GetADC();
215 if(det < 0 || det > 1)
217 AliError(Form("*CPV/PRE NUMBER WRONG %d *",det));
220 if(smn == -1 || smn > 23)
222 AliError(Form("*MODULE NUMBER WRONG %d *",smn));
226 if(xpos < 0 || xpos > 47 || ypos < 0 || ypos > 95)
228 AliError(Form("*Row %d and Column NUMBER %d NOT Valid *",
233 // Pedestal Subtraction
234 Int_t pedmeanrms = fCalibPed->GetPedMeanRms(det,smn,xpos,ypos);
235 Int_t pedrms1 = (Int_t) pedmeanrms%100;
236 Float_t pedrms = (Float_t)pedrms1/10.;
237 Float_t pedmean = (Float_t) (pedmeanrms - pedrms1)/1000.0;
238 //printf("%f %f\n",pedmean, pedrms);
240 Float_t adc1 = adc - (pedmean + 3.0*pedrms);
242 // Hot cell - set the cell adc = 0
243 Float_t hotflag = fCalibHot->GetHotChannel(det,smn,xpos,ypos);
244 if (hotflag == 1.) adc1 = 0;
247 Float_t gain = fCalibGain->GetGainFact(det,smn,xpos,ypos);
248 // printf("adc = %d gain = %f\n",adc,gain);
252 fCellTrack[xpos][ypos] = pmddigit->GetTrackNumber();
253 fCellPid[xpos][ypos] = pmddigit->GetTrackPid();
254 fCellADC[xpos][ypos] = (Double_t) adc;
256 totADCMod += (Int_t) adc;
263 if (totADCMod <= 0) continue;
265 // Set the minimum noise cut per module before clustering
267 // Int_t imod = idet*24 + ismn;
270 // Int_t cluspar = fRecoParam->GetPbPbParam()->GetClusteringParam();
271 Int_t cluspar = fRecoParam->GetPPParam()->GetClusteringParam();
272 // Int_t cluspar = fRecoParam->GetCosmicParam()->GetClusteringParam();
274 pmdclust->SetClusteringParam(cluspar);
277 pmdclust->SetEdepCut(encut);
278 pmdclust->DoClust(idet,ismn,fCellTrack,fCellPid,fCellADC,pmdcont);
280 Int_t nentries1 = pmdcont->GetEntries();
282 AliDebug(1,Form("Total number of clusters/module = %d",nentries1));
284 for (Int_t ient1 = 0; ient1 < nentries1; ient1++)
286 pmdcl = (AliPMDcluster*)pmdcont->UncheckedAt(ient1);
287 idet = pmdcl->GetDetector();
288 ismn = pmdcl->GetSMN();
289 clusdata[0] = pmdcl->GetClusX();
290 clusdata[1] = pmdcl->GetClusY();
291 clusdata[2] = pmdcl->GetClusADC();
292 clusdata[3] = pmdcl->GetClusCells();
293 clusdata[4] = pmdcl->GetClusSigmaX();
294 clusdata[5] = pmdcl->GetClusSigmaY();
296 AddRecPoint(idet,ismn,clusdata);
298 Int_t ncell = (Int_t) clusdata[3];
299 if (ncell > 19) ncell = 19;
300 for(Int_t ihit = 0; ihit < ncell; ihit++)
302 Int_t celldataX = pmdcl->GetClusCellX(ihit);
303 Int_t celldataY = pmdcl->GetClusCellY(ihit);
304 Int_t celldataTr = pmdcl->GetClusCellTrack(ihit);
305 Int_t celldataPid = pmdcl->GetClusCellPid(ihit);
306 Float_t celldataAdc = pmdcl->GetClusCellAdc(ihit);
307 AddRecHit(celldataX, celldataY, celldataTr, celldataPid, celldataAdc);
322 // delete the pointers
326 // ------------------------------------------------------------------------- //
328 void AliPMDClusterFinder::Digits2RecPoints(AliRawReader *rawReader,
331 // Converts RAW data to recpoints after running clustering
332 // algorithm on CPV and PREshower plane
334 // This method is called at the time of reconstruction from RAW data
337 AliPMDddldata *pmdddl = 0x0;
338 AliPMDcluster *pmdcl = 0x0;
341 TObjArray pmdddlcont;
343 TObjArray *pmdcont = new TObjArray();
345 AliPMDClustering *pmdclust = new AliPMDClusteringV1();
347 // access the ddlinfo database to fetch the no of modules per DDL
349 Int_t moduleddl[6] = {0,0,0,0,0,0};
351 for(Int_t jddl = 0; jddl < 6; jddl++)
353 moduleddl[jddl] = fDdlinfo->GetNoOfModulePerDdl(jddl);
356 // Set the minimum noise cut per module before clustering
358 fRecoParam = AliPMDReconstructor::GetRecoParam();
360 if(fRecoParam == 0x0)
362 AliFatal("No Reco Param found for PMD!!!");
367 Int_t bufsize = 16000;
368 TBranch *branch1 = clustersTree->Branch("PMDRecpoint", &fRecpoints, bufsize);
370 TBranch * branch2 = clustersTree->Branch("PMDRechit", &fRechits, bufsize);
372 const Int_t kRow = 48;
373 const Int_t kCol = 96;
379 AliPMDRawStream pmdinput(rawReader);
381 while ((indexDDL = pmdinput.DdlData(&pmdddlcont)) >=0)
383 iSMN = moduleddl[indexDDL];
386 precpvADC = new int **[iSMN];
387 for (Int_t i=0; i<iSMN; i++) precpvADC[i] = new int *[kRow];
388 for (Int_t i=0; i<iSMN;i++)
390 for (Int_t j=0; j<kRow; j++) precpvADC[i][j] = new int [kCol];
392 for (Int_t i = 0; i < iSMN; i++)
394 for (Int_t j = 0; j < kRow; j++)
396 for (Int_t k = 0; k < kCol; k++)
398 precpvADC[i][j][k] = 0;
405 Int_t ientries = pmdddlcont.GetEntries();
406 for (Int_t ient = 0; ient < ientries; ient++)
408 pmdddl = (AliPMDddldata*)pmdddlcont.UncheckedAt(ient);
410 Int_t det = pmdddl->GetDetector();
411 Int_t smn = pmdddl->GetSMN();
412 //Int_t mcm = pmdddl->GetMCM();
413 //Int_t chno = pmdddl->GetChannel();
414 Int_t row = pmdddl->GetRow();
415 Int_t col = pmdddl->GetColumn();
416 Int_t sig = pmdddl->GetSignal();
419 if(det < 0 || det > 1)
421 AliError(Form("*CPV/PRE NUMBER WRONG %d *",det));
424 if(smn < 0 || smn > 23)
426 AliError(Form("*MODULE NUMBER WRONG %d *",smn));
429 if(row < 0 || row > 47 || col < 0 || col > 95)
431 AliError(Form("*Row %d and Column NUMBER %d NOT Valid *",
437 // Pedestal Subtraction
438 Int_t pedmeanrms = fCalibPed->GetPedMeanRms(det,smn,row,col);
439 Int_t pedrms1 = (Int_t) pedmeanrms%100;
440 Float_t pedrms = (Float_t)pedrms1/10.;
441 Float_t pedmean = (Float_t) (pedmeanrms - pedrms1)/1000.0;
443 //printf("%f %f\n",pedmean, pedrms);
445 // Float_t sig1 = (Float_t) sig;
446 Float_t sig1 = (Float_t) sig - (pedmean + 3.0*pedrms);
448 // Hot cell - set the cell adc = 0
449 Float_t hotflag = fCalibHot->GetHotChannel(det,smn,row,col);
450 if (hotflag == 1.) sig1 = 0;
453 Float_t gain = fCalibGain->GetGainFact(det,smn,row,col);
454 //printf("sig = %d gain = %f\n",sig,gain);
455 sig = (Int_t) (sig1*gain);
460 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
470 else if (smn >= 18 && smn < 24)
474 else if (indexDDL >= 1 && indexDDL < 4)
477 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
479 indexsmn = smn - indexDDL * 6;
481 else if (indexDDL == 4)
484 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
490 else if (smn >= 18 && smn < 24)
495 else if (indexDDL == 5)
498 AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
500 if (smn >= 6 && smn < 18)
506 precpvADC[indexsmn][row][col] = sig;
514 for (indexsmn = 0; indexsmn < iSMN; indexsmn++)
518 for (Int_t irow = 0; irow < kRow; irow++)
520 for (Int_t icol = 0; icol < kCol; icol++)
522 fCellTrack[irow][icol] = -1;
523 fCellPid[irow][icol] = -1;
525 fCellADC[irow][icol] =
526 (Double_t) precpvADC[indexsmn][irow][icol];
527 totAdcMod += precpvADC[indexsmn][irow][icol];
542 else if (indexsmn >= 6 && indexsmn < 12)
543 ismn = indexsmn + 12;
547 else if (indexDDL >= 1 && indexDDL < 4)
549 ismn = indexsmn + indexDDL * 6;
552 else if (indexDDL == 4)
558 else if (indexsmn >= 6 && indexsmn < 12)
560 ismn = indexsmn + 12;
564 else if (indexDDL == 5)
570 if (totAdcMod <= 0) continue;
572 Int_t imod = idet*24 + ismn;
574 // Int_t cluspar = fRecoParam->GetPbPbParam()->GetClusteringParam();
575 Int_t cluspar = fRecoParam->GetPPParam()->GetClusteringParam();
576 // Int_t cluspar = fRecoParam->GetCosmicParam()->GetClusteringParam();
577 pmdclust->SetClusteringParam(cluspar);
578 Float_t encut = fNoiseCut->GetNoiseCut(imod);
580 pmdclust->SetEdepCut(encut);
581 pmdclust->DoClust(idet,ismn,fCellTrack,fCellPid,fCellADC,pmdcont);
583 Int_t nentries1 = pmdcont->GetEntries();
585 AliDebug(1,Form("Total number of clusters/module = %d",nentries1));
587 for (Int_t ient1 = 0; ient1 < nentries1; ient1++)
589 pmdcl = (AliPMDcluster*)pmdcont->UncheckedAt(ient1);
590 idet = pmdcl->GetDetector();
591 ismn = pmdcl->GetSMN();
592 clusdata[0] = pmdcl->GetClusX();
593 clusdata[1] = pmdcl->GetClusY();
594 clusdata[2] = pmdcl->GetClusADC();
595 clusdata[3] = pmdcl->GetClusCells();
596 clusdata[4] = pmdcl->GetClusSigmaX();
597 clusdata[5] = pmdcl->GetClusSigmaY();
599 AddRecPoint(idet,ismn,clusdata);
601 Int_t ncell = (Int_t) clusdata[3];
602 if (ncell > 19) ncell = 19;
603 for(Int_t ihit = 0; ihit < ncell; ihit++)
605 Int_t celldataX = pmdcl->GetClusCellX(ihit);
606 Int_t celldataY = pmdcl->GetClusCellY(ihit);
607 Int_t celldataTr = pmdcl->GetClusCellTrack(ihit);
608 Int_t celldataPid = pmdcl->GetClusCellPid(ihit);
609 Float_t celldataAdc = pmdcl->GetClusCellAdc(ihit);
610 AddRecHit(celldataX, celldataY, celldataTr, celldataPid, celldataAdc);
624 for (Int_t i=0; i<iSMN; i++)
626 for (Int_t j=0; j<kRow; j++) delete [] precpvADC[i][j];
628 for (Int_t i=0; i<iSMN; i++) delete [] precpvADC[i];
636 // delete the pointers
640 // ------------------------------------------------------------------------- //
641 void AliPMDClusterFinder::AddRecPoint(Int_t idet,Int_t ismn,Float_t *clusdata)
643 // Add Reconstructed points
645 TClonesArray &lrecpoints = *fRecpoints;
646 AliPMDrecpoint1 *newrecpoint;
647 newrecpoint = new AliPMDrecpoint1(idet, ismn, clusdata);
648 new(lrecpoints[fNpoint++]) AliPMDrecpoint1(newrecpoint);
651 // ------------------------------------------------------------------------- //
652 void AliPMDClusterFinder::AddRecHit(Int_t celldataX,Int_t celldataY,
653 Int_t celldataTr, Int_t celldataPid,
656 // Add associated cell hits to the Reconstructed points
658 TClonesArray &lrechits = *fRechits;
659 AliPMDrechit *newrechit;
660 newrechit = new AliPMDrechit(celldataX, celldataY, celldataTr, celldataPid, celldataAdc);
661 new(lrechits[fNhit++]) AliPMDrechit(newrechit);
664 // ------------------------------------------------------------------------- //
665 void AliPMDClusterFinder::ResetCellADC()
667 // Reset the individual cell ADC value to zero
669 for(Int_t irow = 0; irow < fgkRow; irow++)
671 for(Int_t icol = 0; icol < fgkCol; icol++)
673 fCellTrack[irow][icol] = -1;
674 fCellPid[irow][icol] = -1;
675 fCellADC[irow][icol] = 0.;
679 // ------------------------------------------------------------------------- //
680 void AliPMDClusterFinder::ResetRecpoint()
682 // Clear the list of reconstructed points
684 if (fRecpoints) fRecpoints->Clear();
686 // ------------------------------------------------------------------------- //
687 void AliPMDClusterFinder::ResetRechit()
689 // Clear the list of reconstructed points
691 if (fRechits) fRechits->Clear();
693 // ------------------------------------------------------------------------- //
694 void AliPMDClusterFinder::Load()
696 // Load all the *.root files
698 fPMDLoader->LoadDigits("READ");
699 fPMDLoader->LoadRecPoints("recreate");
701 // ------------------------------------------------------------------------- //
702 void AliPMDClusterFinder::LoadClusters()
704 // Load all the *.root files
706 fPMDLoader->LoadRecPoints("recreate");
708 // ------------------------------------------------------------------------- //
709 void AliPMDClusterFinder::UnLoad()
711 // Unload all the *.root files
713 fPMDLoader->UnloadDigits();
714 fPMDLoader->UnloadRecPoints();
716 // ------------------------------------------------------------------------- //
717 void AliPMDClusterFinder::UnLoadClusters()
719 // Unload all the *.root files
721 fPMDLoader->UnloadRecPoints();
723 // ------------------------------------------------------------------------- //
724 AliPMDCalibData* AliPMDClusterFinder::GetCalibGain() const
726 // The run number will be centralized in AliCDBManager,
727 // you don't need to set it here!
729 AliCDBEntry *entry = AliCDBManager::Instance()->Get("PMD/Calib/Gain");
731 if(!entry) AliFatal("Calibration object retrieval failed! ");
733 AliPMDCalibData *calibdata=0;
734 if (entry) calibdata = (AliPMDCalibData*) entry->GetObject();
736 if (!calibdata) AliFatal("No calibration data from calibration database !");
740 // ------------------------------------------------------------------------- //
741 AliPMDPedestal* AliPMDClusterFinder::GetCalibPed() const
743 // The run number will be centralized in AliCDBManager,
744 // you don't need to set it here!
745 AliCDBEntry *entry = AliCDBManager::Instance()->Get("PMD/Calib/Ped");
747 if(!entry) AliFatal("Pedestal object retrieval failed!");
749 AliPMDPedestal *pedestal = 0;
750 if (entry) pedestal = (AliPMDPedestal*) entry->GetObject();
752 if (!pedestal) AliFatal("No pedestal data from pedestal database !");
756 //--------------------------------------------------------------------//
757 AliPMDHotData* AliPMDClusterFinder::GetCalibHot() const
759 // The run number will be centralized in AliCDBManager,
760 // you don't need to set it here!
761 AliCDBEntry *entry = AliCDBManager::Instance()->Get("PMD/Calib/Hot");
763 if(!entry) AliFatal("HotData object retrieval failed!");
765 AliPMDHotData *hot = 0;
766 if (entry) hot = (AliPMDHotData*) entry->GetObject();
768 if (!hot) AliFatal("No hot data from database !");
772 //--------------------------------------------------------------------//
773 AliPMDNoiseCut* AliPMDClusterFinder::GetNoiseCut() const
775 // The run number will be centralized in AliCDBManager,
776 // you don't need to set it here!
777 AliCDBEntry *entry = AliCDBManager::Instance()->Get("PMD/Calib/NoiseCut");
779 if(!entry) AliFatal("Noisecut object retrieval failed!");
781 AliPMDNoiseCut *ncut = 0;
782 if (entry) ncut = (AliPMDNoiseCut*) entry->GetObject();
784 if (!ncut) AliFatal("No noise cut data from database !");
788 //--------------------------------------------------------------------//
789 AliPMDddlinfoData* AliPMDClusterFinder::GetDdlinfoData() const
791 // The run number will be centralized in AliCDBManager,
792 // you don't need to set it here!
793 AliCDBEntry *entry = AliCDBManager::Instance()->Get("PMD/Calib/Ddlinfo");
795 if(!entry) AliFatal("ddlinfo object retrieval failed!");
797 AliPMDddlinfoData *ddlinfo = 0;
798 if (entry) ddlinfo = (AliPMDddlinfoData*) entry->GetObject();
800 if (!ddlinfo) AliFatal("No ddl info data from database !");