4d2c50ffd00ed62df5d347bee74776adc7b48a6b
[u/mrichter/AliRoot.git] / PMD / AliPMDCalibrator.cxx
1 //////////////////////////////////////////////////////////////////////////////
2 //
3 // * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 // *                                                                        *
5 // * Author: The ALICE Off-line Project.                                    *
6 // * Contributors are mentioned in the code where appropriate.              *
7 // *                                                                        *
8 // * Permission to use, copy, modify and distribute this software and its   *
9 // * documentation strictly for non-commercial purposes is hereby granted   *
10 // * without fee, provided that the above copyright notice appears in all   *
11 // * copies and that both the copyright notice and this permission notice   *
12 // * appear in the supporting documentation. The authors make no claims     *
13 // * about the suitability of this software for any purpose. It is          *
14 // * provided "as is" without express or implied warranty.                  *
15 // **************************************************************************/
16 //
17 //////////////////////////////////////////////////////////////////////////////
18 // Author : Z. Ahamed
19
20 #include "TF1.h"
21 #include "TFile.h"
22 #include "TObjString.h"
23 #include "TROOT.h"
24 #include "TClonesArray.h"
25 #include "TH1F.h"
26 #include "TObjArray.h"
27
28 // --- Standard library ---
29
30 // --- AliRoot header files ---
31 #include "AliLog.h"
32 #include "AliRawReaderFile.h"
33 #include "AliPMDCalibrator.h"
34 #include "AliRawReaderDate.h"
35 #include "AliPMDRawStream.h"
36 #include "AliPMDCalibData.h"
37 #include "AliPMDddldata.h"
38 #include "AliCDBManager.h"
39 #include "AliCDBId.h"
40 #include "AliCDBMetaData.h"
41 #include "AliDAQ.h"
42
43 ClassImp(AliPMDCalibrator)
44
45 const Int_t kDet =2;
46 const Int_t kMaxSMN = 24;
47 const Int_t kMaxRow =96;
48 const Int_t kMaxCol =96;
49
50 AliPMDCalibrator::AliPMDCalibrator()
51 {
52   // Standard Constructor
53
54   fCalibData = new AliPMDCalibData();
55   
56   for(Int_t d=0;d<2;d++)
57     {
58       for(Int_t i=0;i<24;i++)
59         {
60           fHsmIso[d][i] = NULL ;
61           for(Int_t j=0;j<96;j++)
62             {
63               for(Int_t k=0;k<96;k++)
64                 {
65                   fGainFact[d][i][j][k] = 0.0;
66                   fHadcIso[d][i][j][k]  = NULL;
67                 }
68             }
69         }
70     }
71 }
72 // ------------------------------------------------------------------------ //
73
74 AliPMDCalibrator::~AliPMDCalibrator()
75 {
76   // dtor
77   if(fHsmIso)  delete fHsmIso ;
78   if(fHadcIso) delete fHadcIso ;
79   delete fCalibData;
80 }
81 // ------------------------------------------------------------------------ //
82
83 void AliPMDCalibrator::Exec()
84 {
85   // reads parameters and does the calibration
86   CalculateIsoCell() ;
87
88 }
89 // ------------------------------------------------------------------------ //
90
91 void AliPMDCalibrator::Init()
92 {
93   // intializes everything
94   char hname[kMaxSMN];
95   char hname24[kMaxSMN];
96   char hnameiso[120];
97   char htitle1[120];
98
99   for(Int_t d=0;d<2;d++) {
100     for(Int_t i1=0; i1<kMaxSMN;i1++) {
101       sprintf(hname,"det_%d_iso_sm_%2d",d,i1);
102       sprintf(hname24,"det_%d_iso_sm_%2d",d,i1);
103       fHsmIso[d][i1]= new TH1F(hname,hname24,100,0,1000);
104       for(Int_t j1 = 0; j1 < kMaxRow; j1++) {
105         for(Int_t k1 = 0; k1 < kMaxCol; k1++) {
106           sprintf(hnameiso,"Isolated Cell ADC for det_%d_cell_sm%d_row%d_col%d"
107                   ,d,i1,j1,k1);
108           sprintf(htitle1,"Isolated Cell ADC for det_%d_cell_sm%d_row%d_col%d"
109                   ,d,i1,j1,k1);
110           
111           TObject *old=gDirectory->GetList()->FindObject(hnameiso);
112           if (old) gDirectory->GetList()->Remove(old);
113           fHadcIso[d][i1][j1][k1] = new TH1F(hnameiso,htitle1,100,0.,4000.);
114         }
115       }
116     }
117   }
118   
119 }
120
121 // ------------------------------------------------------------------------ //
122
123 void AliPMDCalibrator::CalculateIsoCell()
124 {
125   // Calculates the ADC of isolated cell
126
127   TObjArray pmdddlcont;
128   const Int_t kDDL           = AliDAQ::NumberOfDdls("PMD");
129   const Int_t kMaxHit        = 60000;
130   const Int_t kCellNeighbour = 6;
131
132   Int_t neibx[6] = {1,0,-1,-1,0,1};
133   Int_t neiby[6] = {0,1,1,0,-1,-1};
134   
135   Int_t id1,jd1; //neighbour row/col
136   Int_t countisocell = 0 ;//number of isilated cell
137   Int_t isocount; //number of neighbours with 0 signal
138   Int_t d1[kDet][kMaxSMN][kMaxRow][kMaxCol];
139   Int_t ch[kDet][kMaxSMN][kMaxRow][kMaxCol];
140   Int_t maxhit;
141   
142   
143   Int_t det[kMaxHit],smn[kMaxHit];
144   Int_t row[kMaxHit],col[kMaxHit],sig[kMaxHit],chno[kMaxHit];
145
146   for(Int_t idet = 0; idet < kDet; idet++)
147     {
148       for(Int_t ismn = 0; ismn < kMaxSMN; ismn++)
149         {
150           for(Int_t irow = 0; irow < kMaxRow; irow++)
151             {
152               for(Int_t icol = 0; icol < kMaxCol; icol++)
153                 {
154                   d1[idet][ismn][irow][icol] = 0;
155                   ch[idet][ismn][irow][icol] = 0;
156                 }
157             }
158         }
159     }
160   //accessing raw data
161   AliRawReaderFile reader(".");
162   AliPMDRawStream stream(&reader);
163   while(reader.NextEvent())
164     {
165       // printf("In CalculateIsoCell before while(stream.Next()), ...\n");
166       
167       /*
168       while(stream.Next())
169         {
170           Int_t idet = stream.GetDetector();
171           Int_t ismn = stream.GetSMN();
172           Int_t ichno = stream.GetChannel();
173           Int_t irow = stream.GetRow();
174           Int_t icol = stream.GetColumn();
175           Int_t isig = stream.GetSignal();
176           
177           if (isig>0)
178             {
179               d1[idet][ismn][irow][icol] = isig;
180               ch[idet][ismn][irow][icol] = ichno;
181             }
182         }
183       */
184       // New PMD Reader is plugged in
185       
186       for (Int_t iddl = 0; iddl < kDDL; iddl++)
187         {
188           reader.Select("PMD", iddl, iddl);
189           stream.DdlData(&pmdddlcont);
190           
191           Int_t ientries = pmdddlcont.GetEntries();
192           for (Int_t ient = 0; ient < ientries; ient++)
193             {
194               AliPMDddldata *pmdddl = (AliPMDddldata*)pmdddlcont.UncheckedAt(ient);
195               
196               Int_t idet = pmdddl->GetDetector();
197               Int_t ismn = pmdddl->GetSMN();
198               //Int_t mcm = pmdddl->GetMCM();
199               Int_t ichno = pmdddl->GetChannel();
200               Int_t irow = pmdddl->GetRow();
201               Int_t icol = pmdddl->GetColumn();
202               Int_t isig = pmdddl->GetSignal();
203               
204               if (isig>0)
205                 {
206                   d1[idet][ismn][irow][icol] = isig;
207                   ch[idet][ismn][irow][icol] = ichno;
208                 }
209             }
210           pmdddlcont.Clear();
211         }
212
213
214       maxhit = 0;
215       
216       for(Int_t idet=0; idet < kDet; idet++)
217         {
218           for(Int_t ismn = 0; ismn < kMaxSMN; ismn++)
219             {
220               for(Int_t irow = 0; irow < kMaxRow; irow++)
221                 {
222                   for(Int_t icol = 0; icol < kMaxCol; icol++)
223                     {
224                       
225                       //printf("d1[%d][%d][%d][%d]=%d\n",
226                       //det,ksmn,irow,jcol, d1[det][ksmn][irow][jcol] ); 
227                       //printf("ch[%d][%d][%d][%d]=%d\n",
228                       //det,ksmn,irow,jcol, ch[det][ksmn][irow][jcol] ); 
229                       
230                       if(d1[idet][ismn][irow][icol] > 0)
231                         {
232                           isocount = 0;
233                           for(Int_t ii = 0; ii < kCellNeighbour; ii++)
234                             {
235                               id1 = irow + neibx[ii];
236                               jd1 = icol + neiby[ii];
237                               if(d1[idet][ismn][id1][jd1] == 0)
238                                 {
239                                   isocount++;
240                                   if(isocount == kCellNeighbour)
241                                     {
242                                       countisocell++;
243                                       det[maxhit]  = idet;
244                                       smn[maxhit]  = ismn;
245                                       row[maxhit]  = irow;
246                                       col[maxhit]  = icol;
247                                       sig[maxhit]  = d1[idet][ismn][irow][icol];
248                                       chno[maxhit] = ch[idet][ismn][irow][icol];
249                                       maxhit++;
250                                       fHsmIso[idet][ismn]->Fill(d1[idet][ismn][irow][icol]);
251                                       fHadcIso[idet][ismn][irow][icol]->Fill(d1[idet][ismn][irow][icol]);
252                                     }
253                                 }
254                             }  // neigh cell cond.
255                         }     // d>0 cond.
256                     }
257                 }
258             }
259         } //event loop
260     }
261   Double_t histMean[2][24];
262   Double_t isoMean[2][24][96][96];
263   for(Int_t d1=0;d1<2;d1++)
264     {
265       for(Int_t i1=0;i1<24;i1++)
266         {
267           histMean[d1][i1]= fHsmIso[d1][i1]->GetMean();
268           for(Int_t j1=0;j1<96;j1++)
269             {
270               for(Int_t k1=0;k1<96;k1++)
271                 {
272                   isoMean[d1][i1][j1][k1]=fHadcIso[d1][i1][j1][k1]->GetMean();
273                   if(isoMean[d1][i1][j1][k1]>0.0 && histMean[d1][i1]>0.0)
274                     {
275                       fGainFact[d1][i1][j1][k1]=isoMean[d1][i1][k1][j1]/histMean[d1][i1];
276                       Float_t gain=fGainFact[d1][i1][j1][k1];
277                       fCalibData->SetGainFact(d1,i1,j1,k1,gain);
278                     }                              
279                 }
280             }
281         }
282     }
283   
284 }
285 // ------------------------------------------------------------------------ //
286 Bool_t AliPMDCalibrator::Store()
287 {
288   AliCDBManager *man = AliCDBManager::Instance();
289   man->SetDefaultStorage("local://$ALICE_ROOT");
290   AliCDBId id("PMD/Calib/Data",0,0);
291   AliCDBMetaData md;
292   md.SetResponsible("Zubayer");
293   md.SetBeamPeriod(0);
294   md.SetAliRootVersion("28.02.2006");
295   md.SetComment("Test");
296   
297   printf("\n\n\n fCalibData\n");
298   //fCalibData->Print(0);
299   //printf("\n\n\n fCalibData\n");
300   
301   Bool_t result = man->Put(fCalibData,id,&md);
302
303   return result;
304 }
305