b937a53dcb660ee86ebede38c57fcf45342c60a5
[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 <TMath.h>
35 #include <TSystem.h>
36 #include <Riostream.h>
37
38 AliT0CalibData* AliT0Parameters::fgCalibData = 0;
39 AliT0CalibData* AliT0Parameters::fgLookUp = 0;
40 AliT0CalibData* AliT0Parameters::fgSlewCorr =0;
41 //====================================================================
42 ClassImp(AliT0Parameters)
43 #if 0
44   ; // This is here to keep Emacs for indenting the next line
45 #endif
46
47 //____________________________________________________________________
48 AliT0Parameters* AliT0Parameters::fgInstance = 0;
49 //____________________________________________________________________
50 AliT0Parameters* 
51 AliT0Parameters::Instance() 
52 {
53   // Get static instance 
54   if (!fgInstance) fgInstance = new AliT0Parameters;
55   return fgInstance;
56 }
57
58 //____________________________________________________________________
59 AliT0Parameters::AliT0Parameters()
60   :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()
61 {
62   // Default constructor 
63
64   for (Int_t ipmt=0; ipmt<24; ipmt++)
65     {
66       SetSlewingLED(ipmt);
67       SetSlewingRec(ipmt);
68       SetWalk(ipmt);
69       SetPh2Mip();      
70       SetmV2Mip();      
71       SetChannelWidth();
72       SetmV2channel();
73       SetQTmin();
74       SetQTmax();
75       SetPMTeff(ipmt);
76
77    }
78   SetTimeDelayTVD();
79   SetZposition();
80   
81 }
82
83 //__________________________________________________________________
84 void
85 AliT0Parameters::Init()
86 {
87   // Initialize the parameters manager.  We need to get stuff from the
88   // CDB here. 
89   //   if (fIsInit) return;
90   
91
92   AliCDBStorage *stor =AliCDBManager::Instance()->GetStorage("local://$ALICE_ROOT");
93   //time equalizing
94   AliCDBEntry* fCalibentry  = stor->Get("T0/Calib/TimeDelay",0);
95  if (fCalibentry){
96    fgCalibData  = (AliT0CalibData*)fCalibentry->GetObject();
97   }
98  else 
99    { AliError(" ALARM !!!! No time delays in CDB "); }
100  //slewing correction
101   AliCDBEntry* fSlewCorr  = stor->Get("T0/Calib/Slewing_Walk",0);
102  if (fSlewCorr){
103    fgSlewCorr  = (AliT0CalibData*)fSlewCorr->GetObject();
104   }
105   fLookUpentry  = stor->Get("T0/Calib/LookUp_Table",0);
106   if (fLookUpentry){
107     fgLookUp  = (AliT0CalibData*)fLookUpentry->GetObject();
108   }
109   else {
110   const char * filename = gSystem->ExpandPathName("$ALICE_ROOT/T0/lookUpTable.txt");
111   ifstream inFile(filename);
112   fgLookUp->ReadAsciiLookup(filename);
113   }
114
115   fIsInit = kTRUE;
116 }
117
118
119 //__________________________________________________________________
120 Float_t
121 AliT0Parameters::GetTimeDelayLED(Int_t ipmt) 
122 {
123   // return time delay for LED channel
124   // 
125   if (!fCalibentry) {
126     fTimeDelayLED = 0;
127     return  fTimeDelayLED;
128   } 
129   return fgCalibData ->GetTimeDelayLED(ipmt);
130 }
131 //__________________________________________________________________
132 Float_t
133 AliT0Parameters::GetTimeDelayCFD(Int_t ipmt) 
134 {
135   // return time delay for CFD channel
136    // 
137   if (!fCalibentry) 
138     {
139       fTimeDelayCFD = 1000+ipmt*100;
140       return fTimeDelayCFD;
141     }
142    
143   return fgCalibData->GetTimeDelayCFD(ipmt);
144 }
145
146 //__________________________________________________________________
147
148 void 
149 AliT0Parameters::SetSlewingLED(Int_t ipmt)
150 {
151   //  Set Slweing Correction for LED channel 
152      Float_t mv[23] = {25, 30,40,60, 80,100,150,200,250,300,
153                        400,500,600,800,1000,1500, 2000, 3000, 4000, 5500,
154                        6000, 7000,8000};
155       Float_t y[23] = {5044, 4719, 3835, 3224, 2847, 2691,2327, 2067, 1937, 1781,
156                        1560, 1456 ,1339, 1163.5, 1027, 819, 650, 520, 370.5, 234,
157                        156, 78, 0};
158       
159       TGraph* gr = new TGraph(23,mv,y);
160       fSlewingLED.AddAtAndExpand(gr,ipmt);
161   }
162 //__________________________________________________________________
163
164 Float_t AliT0Parameters::GetSlewingLED(Int_t ipmt, Float_t mv) const
165 {
166   if (!fCalibentry) {
167     return ((TGraph*)fSlewingLED.At(ipmt))->Eval(mv); 
168   } 
169   return fgCalibData->GetSlewingLED(ipmt, mv) ;
170 }
171
172
173 //__________________________________________________________________
174
175 TGraph *AliT0Parameters::GetSlew(Int_t ipmt) const
176 {
177   if (!fCalibentry) {
178     return  (TGraph*)fSlewingLED.At(ipmt); 
179   } 
180   return fgCalibData -> GetSlew(ipmt) ;
181 }
182
183 //__________________________________________________________________
184
185
186 void 
187 AliT0Parameters::SetSlewingRec(Int_t ipmt)
188 {
189   //  Set Slweing Correction for LED channel 
190       Float_t mv[23] = {25, 30, 40,60, 80,100,150,200,250,300,
191                         400,500,600,800,1000,1500, 2000, 3000, 4000, 5500,
192                         6000, 7000,8000};
193       Float_t y[23] = {5044, 4719, 3835, 3224, 2847, 2691,2327, 2067, 1937, 1781, 
194                        1560, 1456 ,1339, 1163.5, 1027, 819, 650, 520, 370.5, 234, 
195                        156, 78, 0};
196       Float_t y1[23], mv1[23];
197       for (Int_t i=0; i<23; i++){
198         y1[i] = y[22-i]; mv1[i] = mv[22-i];}
199
200       TGraph* gr = new TGraph(23,y1,mv1);
201       fSlewingRec.AddAtAndExpand(gr,ipmt);
202
203 }
204 //__________________________________________________________________
205
206 Float_t AliT0Parameters::GetSlewingRec(Int_t ipmt, Float_t mv) const
207 {
208   if (!fCalibentry) {
209     return ((TGraph*)fSlewingRec.At(ipmt))->Eval(mv); 
210   } 
211   return fgCalibData -> GetSlewingRec(ipmt, mv) ;
212 }
213
214 //__________________________________________________________________
215
216 TGraph *AliT0Parameters::GetSlewRec(Int_t ipmt) const
217 {
218   if (!fCalibentry) {
219     return  (TGraph*)fSlewingRec.At(ipmt); 
220   } 
221   return fgCalibData -> GetSlewRec(ipmt) ;
222 }
223
224
225 //________________________________________________________________
226 void AliT0Parameters::SetWalk(Int_t ipmt)
227 {
228
229  Int_t mv, ps; 
230   Int_t x[70000], y[70000], index[70000];
231   Float_t time[10000],amplitude[10000];
232   string buffer;
233   Bool_t down=false;
234   
235   const char * filename = gSystem->ExpandPathName("$ALICE_ROOT/T0/data/CFD-Amp.txt");
236   ifstream inFile(filename);
237   //  if(!inFile) AliError(Form("Cannot open file %s !",filename));
238   
239   Int_t i=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<i; 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 }