Default calibration (A.Colla)
[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
27 // --- Standard library ---
28
29 // --- AliRoot header files ---
30 #include "AliLog.h"
31 #include "AliPMDCalibrator.h"
32 #include "AliRawReaderDate.h"
33 #include "AliPMDRawStream.h"
34 #include "AliRawReaderFile.h"
35 #include "AliPMDCalibData.h"
36 #include "AliCDBManager.h"
37 #include "AliCDBId.h"
38 #include "AliCDBMetaData.h"
39
40 ClassImp(AliPMDCalibrator)
41
42 const Int_t kDet =2;
43 const Int_t kMaxSMN = 24;
44 const Int_t kMaxRow =96;
45 const Int_t kMaxCol =96;
46
47 AliPMDCalibrator::AliPMDCalibrator()
48 {
49   // Standard Constructor
50
51   fCalibData = new AliPMDCalibData();
52   
53   for(Int_t d=0;d<2;d++)
54     {
55       for(Int_t i=0;i<24;i++)
56         {
57           fHsmIso[d][i] = NULL ;
58           for(Int_t j=0;j<96;j++)
59             {
60               for(Int_t k=0;k<96;k++)
61                 {
62                   fGainFact[d][i][j][k] = 0.0;
63                   fHadcIso[d][i][j][k]  = NULL;
64                 }
65             }
66         }
67     }
68 }
69 // ------------------------------------------------------------------------ //
70
71 AliPMDCalibrator::~AliPMDCalibrator()
72 {
73   // dtor
74   if(fHsmIso)  delete fHsmIso ;
75   if(fHadcIso) delete fHadcIso ;
76   delete fCalibData;
77 }
78 // ------------------------------------------------------------------------ //
79
80 void AliPMDCalibrator::Exec()
81 {
82   // reads parameters and does the calibration
83   CalculateIsoCell() ;
84
85 }
86 // ------------------------------------------------------------------------ //
87
88 void AliPMDCalibrator::Init()
89 {
90   // intializes everything
91   char hname[kMaxSMN];
92   char hname24[kMaxSMN];
93   char hnameiso[120];
94   char htitle1[120];
95
96   for(Int_t d=0;d<2;d++) {
97     for(Int_t i1=0; i1<kMaxSMN;i1++) {
98       sprintf(hname,"det_%d_iso_sm_%2d",d,i1);
99       sprintf(hname24,"det_%d_iso_sm_%2d",d,i1);
100       fHsmIso[d][i1]= new TH1F(hname,hname24,100,0,1000);
101       for(Int_t j1 = 0; j1 < kMaxRow; j1++) {
102         for(Int_t k1 = 0; k1 < kMaxCol; k1++) {
103           sprintf(hnameiso,"Isolated Cell ADC for det_%d_cell_sm%d_row%d_col%d"
104                   ,d,i1,j1,k1);
105           sprintf(htitle1,"Isolated Cell ADC for det_%d_cell_sm%d_row%d_col%d"
106                   ,d,i1,j1,k1);
107           
108           TObject *old=gDirectory->GetList()->FindObject(hnameiso);
109           if (old) gDirectory->GetList()->Remove(old);
110           fHadcIso[d][i1][j1][k1] = new TH1F(hnameiso,htitle1,100,0.,4000.);
111         }
112       }
113     }
114   }
115   
116 }
117
118 // ------------------------------------------------------------------------ //
119
120 void AliPMDCalibrator::CalculateIsoCell()
121 {
122   // Calculates the ADC of isolated cell
123
124   const Int_t kMaxHit        = 60000;
125   const Int_t kCellNeighbour = 6;
126
127   Int_t neibx[6] = {1,0,-1,-1,0,1};
128   Int_t neiby[6] = {0,1,1,0,-1,-1};
129   
130   Int_t id1,jd1; //neighbour row/col
131   Int_t countisocell = 0 ;//number of isilated cell
132   Int_t isocount; //number of neighbours with 0 signal
133   Int_t d1[kDet][kMaxSMN][kMaxRow][kMaxCol];
134   Int_t ch[kDet][kMaxSMN][kMaxRow][kMaxCol];
135   Int_t maxhit;
136   
137   
138   Int_t det[kMaxHit],smn[kMaxHit];
139   Int_t row[kMaxHit],col[kMaxHit],sig[kMaxHit],chno[kMaxHit];
140
141   for(Int_t idet = 0; idet < kDet; idet++)
142     {
143       for(Int_t ismn = 0; ismn < kMaxSMN; ismn++)
144         {
145           for(Int_t irow = 0; irow < kMaxRow; irow++)
146             {
147               for(Int_t icol = 0; icol < kMaxCol; icol++)
148                 {
149                   d1[idet][ismn][irow][icol] = 0;
150                   ch[idet][ismn][irow][icol] = 0;
151                 }
152             }
153         }
154     }
155   //accessing raw data
156   AliRawReaderFile reader(".");
157   AliPMDRawStream stream(&reader);
158   while(reader.NextEvent())
159     {
160       // printf("In CalculateIsoCell before while(stream.Next()), ...\n");
161       
162       while(stream.Next())
163         {
164           Int_t idet = stream.GetDetector();
165           Int_t ismn = stream.GetSMN();
166           Int_t ichno = stream.GetChannel();
167           Int_t irow = stream.GetRow();
168           Int_t icol = stream.GetColumn();
169           Int_t isig = stream.GetSignal();
170           
171           if (isig>0)
172             {
173               d1[idet][ismn][irow][icol] = isig;
174               ch[idet][ismn][irow][icol] = ichno;
175             }
176         }
177       
178       maxhit = 0;
179       
180       for(Int_t idet=0; idet < kDet; idet++)
181         {
182           for(Int_t ismn = 0; ismn < kMaxSMN; ismn++)
183             {
184               for(Int_t irow = 0; irow < kMaxRow; irow++)
185                 {
186                   for(Int_t icol = 0; icol < kMaxCol; icol++)
187                     {
188                       
189                       //printf("d1[%d][%d][%d][%d]=%d\n",
190                       //det,ksmn,irow,jcol, d1[det][ksmn][irow][jcol] ); 
191                       //printf("ch[%d][%d][%d][%d]=%d\n",
192                       //det,ksmn,irow,jcol, ch[det][ksmn][irow][jcol] ); 
193                       
194                       if(d1[idet][ismn][irow][icol] > 0)
195                         {
196                           isocount = 0;
197                           for(Int_t ii = 0; ii < kCellNeighbour; ii++)
198                             {
199                               id1 = irow + neibx[ii];
200                               jd1 = icol + neiby[ii];
201                               if(d1[idet][ismn][id1][jd1] == 0)
202                                 {
203                                   isocount++;
204                                   if(isocount == kCellNeighbour)
205                                     {
206                                       countisocell++;
207                                       det[maxhit]  = idet;
208                                       smn[maxhit]  = ismn;
209                                       row[maxhit]  = irow;
210                                       col[maxhit]  = icol;
211                                       sig[maxhit]  = d1[idet][ismn][irow][icol];
212                                       chno[maxhit] = ch[idet][ismn][irow][icol];
213                                       maxhit++;
214                                       fHsmIso[idet][ismn]->Fill(d1[idet][ismn][irow][icol]);
215                                       fHadcIso[idet][ismn][irow][icol]->Fill(d1[idet][ismn][irow][icol]);
216                                     }
217                                 }
218                             }  // neigh cell cond.
219                         }     // d>0 cond.
220                     }
221                 }
222             }
223         } //event loop
224     }
225   Double_t histMean[2][24];
226   Double_t isoMean[2][24][96][96];
227   for(Int_t d1=0;d1<2;d1++)
228     {
229       for(Int_t i1=0;i1<24;i1++)
230         {
231           histMean[d1][i1]= fHsmIso[d1][i1]->GetMean();
232           for(Int_t j1=0;j1<96;j1++)
233             {
234               for(Int_t k1=0;k1<96;k1++)
235                 {
236                   isoMean[d1][i1][j1][k1]=fHadcIso[d1][i1][j1][k1]->GetMean();
237                   if(isoMean[d1][i1][j1][k1]>0.0 && histMean[d1][i1]>0.0)
238                     {
239                       fGainFact[d1][i1][j1][k1]=isoMean[d1][i1][k1][j1]/histMean[d1][i1];
240                       Float_t gain=fGainFact[d1][i1][j1][k1];
241                       fCalibData->SetGainFact(d1,i1,j1,k1,gain);
242                     }                              
243                 }
244             }
245         }
246     }
247   
248 }
249 // ------------------------------------------------------------------------ //
250 Bool_t AliPMDCalibrator::Store()
251 {
252   AliCDBManager *man = AliCDBManager::Instance();
253   man->SetDefaultStorage("local://$ALICE_ROOT");
254   AliCDBId id("PMD/Calib/Data",0,0);
255   AliCDBMetaData md;
256   md.SetResponsible("Zubayer");
257   md.SetBeamPeriod(0);
258   md.SetAliRootVersion("28.02.2006");
259   md.SetComment("Test");
260   
261   printf("\n\n\n fCalibData\n");
262   //fCalibData->Print(0);
263   //printf("\n\n\n fCalibData\n");
264   
265   Bool_t result = man->Put(fCalibData,id,&md);
266
267   return result;
268 }
269