more realistic calibration
[u/mrichter/AliRoot.git] / T0 / AliT0Parameters.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
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  **************************************************************************/
15
16 /* $Id:  */
17
18 //____________________________________________________________________
19 //                                                                          
20 // T0 - T0. 
21 //
22 // This class is a singleton that handles various parameters of
23 // the T0 detectors.  
24 // Eventually, this class will use the Conditions DB to get the
25 // various parameters, which code can then request from here.
26 //                                                       
27 #include "AliLog.h"               
28 #include "AliT0Parameters.h"      
29 #include "AliT0CalibData.h"   
30 #include "AliT0LookUpValue.h"
31 #include <AliCDBManager.h>        
32 #include <AliCDBEntry.h>          
33 #include <AliCDBStorage.h>          
34 #include <Riostream.h>
35
36 AliT0CalibData* AliT0Parameters::fgCalibData = 0;
37 AliT0CalibData* AliT0Parameters::fgLookUp = 0;
38 AliT0CalibData* AliT0Parameters::fgSlewCorr =0;
39 //====================================================================
40 ClassImp(AliT0Parameters)
41 #if 0
42   ; // This is here to keep Emacs for indenting the next line
43 #endif
44
45 //____________________________________________________________________
46 AliT0Parameters* AliT0Parameters::fgInstance = 0;
47 //____________________________________________________________________
48 AliT0Parameters* 
49 AliT0Parameters::Instance() 
50 {
51   // Get static instance 
52   if (!fgInstance) fgInstance = new AliT0Parameters;
53   return fgInstance;
54 }
55
56 //____________________________________________________________________
57 AliT0Parameters::AliT0Parameters()
58   :fIsInit(kFALSE),fPh2Mip(0),fmV2Mip(0),fChannelWidth(0),fmV2Channel(0),fQTmin(0),fQTmax(0),fSlewingLED(),fSlewingRec(),fPMTeff(),fTimeDelayLED(0),fTimeDelayCFD(0),fTimeDelayTVD(0),fCalibentry(), fLookUpentry(),fSlewCorr()
59 {
60   // Default constructor 
61
62   for (Int_t ipmt=0; ipmt<24; ipmt++)
63     {
64       SetSlewingLED(ipmt);
65       SetSlewingRec(ipmt);
66       SetWalk(ipmt);
67       SetPh2Mip();      
68       SetmV2Mip();      
69       SetChannelWidth();
70       SetmV2channel();
71       SetQTmin();
72       SetQTmax();
73       SetPMTeff(ipmt);
74
75    }
76   SetTimeDelayTVD();
77   SetZposition();
78   
79 }
80
81 //__________________________________________________________________
82 void
83 AliT0Parameters::Init()
84 {
85   // Initialize the parameters manager.  We need to get stuff from the
86   // CDB here. 
87   //   if (fIsInit) return;
88   
89   // AliCDBManager* cdb      = AliCDBManager::Instance();
90   // fCalibentry  = cdb->Get("T0/Calib/Gain_TimeDelay_Slewing_Walk");
91  
92
93   AliCDBStorage *stor =AliCDBManager::Instance()->GetStorage("local://$ALICE_ROOT");
94   //time equalizing
95   AliCDBEntry* fCalibentry  = stor->Get("T0/Calib/TimeDelay",0);
96  if (fCalibentry){
97    fgCalibData  = (AliT0CalibData*)fCalibentry->GetObject();
98   }
99  else 
100    { AliError(" ALARM !!!! No time delays in CDB "); }
101  //slewing correction
102   AliCDBEntry* fSlewCorr  = stor->Get("T0/Calib/Slewing_Walk",0);
103  if (fSlewCorr){
104    fgSlewCorr  = (AliT0CalibData*)fSlewCorr->GetObject();
105   }
106  // fLookUpentry  = cdb->Get("T0/Calib/LookUp_Table");
107   fLookUpentry  = stor->Get("T0/Calib/LookUp_Table",0);
108   if (fLookUpentry){
109     fgLookUp  = (AliT0CalibData*)fLookUpentry->GetObject();
110     //   fgLookUp->Dump();
111   }
112   else {
113     fgLookUp->ReadAsciiLookup("$ALICE_ROOT/T0/lookUpTable.txt");
114   }
115
116   fIsInit = kTRUE;
117 }
118
119
120 //__________________________________________________________________
121 Float_t
122 AliT0Parameters::GetTimeDelayLED(Int_t ipmt) 
123 {
124   // return time delay for LED channel
125   // 
126   if (!fCalibentry) {
127     fTimeDelayLED = 0;
128     return  fTimeDelayLED;
129   } 
130   return fgCalibData ->GetTimeDelayLED(ipmt);
131 }
132 //__________________________________________________________________
133 Float_t
134 AliT0Parameters::GetTimeDelayCFD(Int_t ipmt) 
135 {
136   // return time delay for CFD channel
137    // 
138   if (!fCalibentry) 
139     {
140       fTimeDelayCFD = 1000+ipmt*100;
141       return fTimeDelayCFD;
142     }
143    
144   return fgCalibData->GetTimeDelayCFD(ipmt);
145 }
146
147 //__________________________________________________________________
148
149 void 
150 AliT0Parameters::SetSlewingLED(Int_t ipmt)
151 {
152   //  Set Slweing Correction for LED channel 
153      Float_t mv[23] = {25, 30,40,60, 80,100,150,200,250,300,
154                        400,500,600,800,1000,1500, 2000, 3000, 4000, 5500,
155                        6000, 7000,8000};
156       Float_t y[23] = {5044, 4719, 3835, 3224, 2847, 2691,2327, 2067, 1937, 1781,
157                        1560, 1456 ,1339, 1163.5, 1027, 819, 650, 520, 370.5, 234,
158                        156, 78, 0};
159       
160       TGraph* gr = new TGraph(23,mv,y);
161       fSlewingLED.AddAtAndExpand(gr,ipmt);
162   }
163 //__________________________________________________________________
164
165 Float_t AliT0Parameters::GetSlewingLED(Int_t ipmt, Float_t mv) const
166 {
167   if (!fCalibentry) {
168     return ((TGraph*)fSlewingLED.At(ipmt))->Eval(mv); 
169   } 
170   return fgCalibData->GetSlewingLED(ipmt, mv) ;
171 }
172
173
174 //__________________________________________________________________
175
176 TGraph *AliT0Parameters::GetSlew(Int_t ipmt) const
177 {
178   if (!fCalibentry) {
179     return  (TGraph*)fSlewingLED.At(ipmt); 
180   } 
181   return fgCalibData -> GetSlew(ipmt) ;
182 }
183
184 //__________________________________________________________________
185
186
187 void 
188 AliT0Parameters::SetSlewingRec(Int_t ipmt)
189 {
190   //  Set Slweing Correction for LED channel 
191       Float_t mv[23] = {25, 30, 40,60, 80,100,150,200,250,300,
192                         400,500,600,800,1000,1500, 2000, 3000, 4000, 5500,
193                         6000, 7000,8000};
194       Float_t y[23] = {5044, 4719, 3835, 3224, 2847, 2691,2327, 2067, 1937, 1781, 
195                        1560, 1456 ,1339, 1163.5, 1027, 819, 650, 520, 370.5, 234, 
196                        156, 78, 0};
197       Float_t y1[23], mv1[23];
198       for (Int_t i=0; i<23; i++){
199         y1[i] = y[22-i]; mv1[i] = mv[22-i];}
200
201       TGraph* gr = new TGraph(23,y1,mv1);
202       fSlewingRec.AddAtAndExpand(gr,ipmt);
203
204 }
205 //__________________________________________________________________
206
207 Float_t AliT0Parameters::GetSlewingRec(Int_t ipmt, Float_t mv) const
208 {
209   if (!fCalibentry) {
210     return ((TGraph*)fSlewingRec.At(ipmt))->Eval(mv); 
211   } 
212   return fgCalibData -> GetSlewingRec(ipmt, mv) ;
213 }
214
215 //__________________________________________________________________
216
217 TGraph *AliT0Parameters::GetSlewRec(Int_t ipmt) const
218 {
219   if (!fCalibentry) {
220     return  (TGraph*)fSlewingRec.At(ipmt); 
221   } 
222   return fgCalibData -> GetSlewRec(ipmt) ;
223 }
224
225
226 //________________________________________________________________
227 void AliT0Parameters::SetWalk(Int_t ipmt)
228 {
229
230  Int_t mv, ps; 
231   Int_t x[70000], y[70000], index[70000];
232   Float_t time[10000],amplitude[10000];
233   string buffer;
234   Bool_t down=false;
235   
236   ifstream inFile("data/CFD-Amp.txt");
237   //  if(!inFile) AliError(Form("Cannot open file %s !",filename));
238   
239   Int_t i=0, i1=0, i2=0;
240   while(getline(inFile,buffer)){
241     inFile >> ps >> mv;
242
243     x[i]=ps; y[i]=mv;
244     i++;
245   }
246   inFile.close();
247  
248   TMath::Sort(i, y, index,down);
249   Int_t amp=0, iin=0, isum=0, sum=0;
250   Int_t ind=0;
251   for (Int_t ii=0; ii<70000; ii++)
252     {
253       ind=index[ii];
254       if(y[ind] == amp)
255         {
256           sum +=x[ind];
257           iin++;
258         }
259       else
260         {
261           if(iin>0)
262             time[isum] = Float_t (sum/(iin));
263           else
264             time[isum] =Float_t (x[ind]);
265           amplitude[isum] = Float_t (amp);
266           amp=y[ind];
267           //      cout<<ii<<" "<<ind<<" "<<y[ind]<<" "<<x[ind]<<" iin "<<iin<<" mean "<<time[isum]<<" amp "<< amplitude[isum]<<" "<<isum<<endl;
268           iin=0;
269           isum++;
270           sum=0;
271         }
272
273
274     }
275
276   inFile.close();
277
278    TGraph* gr = new TGraph(isum, amplitude, time);
279   fWalk.AddAtAndExpand(gr,ipmt);
280   
281   
282 }
283 //__________________________________________________________________
284
285 TGraph *AliT0Parameters::GetWalk(Int_t ipmt) const
286 {
287   if (!fCalibentry) {
288     return  (TGraph*)fWalk.At(ipmt); 
289   } 
290   return fgCalibData -> GetWalk(ipmt) ;
291 }
292
293 //__________________________________________________________________
294
295 Float_t AliT0Parameters::GetWalkVal(Int_t ipmt, Float_t mv) const
296 {
297   if (!fCalibentry) {
298     return ((TGraph*)fWalk.At(ipmt))->Eval(mv); 
299   } 
300   return fgCalibData -> GetWalkVal(ipmt, mv) ;
301 }
302
303 //__________________________________________________________________
304
305 //__________________________________________________________________
306 void 
307 AliT0Parameters::SetPMTeff(Int_t ipmt)
308 {
309   Float_t lambda[50];
310   Float_t eff[50 ] = {0,        0,       0.23619,  0.202909, 0.177913, 
311                     0.175667, 0.17856, 0.190769, 0.206667, 0.230286,
312                     0.252276, 0.256267,0.26,     0.27125,  0.281818,
313                     0.288118, 0.294057,0.296222, 0.301622, 0.290421, 
314                     0.276615, 0.2666,  0.248,    0.23619,  0.227814, 
315                     0.219818, 0.206667,0.194087, 0.184681, 0.167917, 
316                     0.154367, 0.1364,  0.109412, 0.0834615,0.0725283, 
317                     0.0642963,0.05861, 0.0465,   0.0413333,0.032069, 
318                     0.0252203,0.02066, 0.016262, 0.012,    0.00590476,
319                     0.003875, 0.00190, 0,        0,        0          } ;
320   for (Int_t i=0; i<50; i++) lambda[i]=200+10*i; 
321
322   TGraph* gr = new TGraph(50,lambda,eff);
323   fPMTeff.AddAtAndExpand(gr,ipmt);
324 }
325 //________________________________________________________________
326
327 Int_t 
328 AliT0Parameters::GetChannel(Int_t trm,  Int_t tdc, Int_t chain, Int_t channel)
329 {
330
331   
332   AliT0LookUpKey * lookkey;  //= new AliT0LookUpKey();
333   AliT0LookUpValue * lookvalue= new AliT0LookUpValue(trm,tdc,chain,channel);
334     
335    lookkey = (AliT0LookUpKey*) fgLookUp->GetMapLookup()->GetValue((TObject*)lookvalue);
336   if (!lookkey ) {
337     cout<<" no such address "<<endl; return -1;
338   }
339   
340
341   //cout<<"AliT0Parameters:: key "<<lookkey->GetKey()<<endl;
342   return lookkey->GetKey();
343   
344
345 }