reading Zposition from DB, the same RawReader for sim. and test data, reading detecto...
[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 #include <TGeoManager.h>
38 #include <TGeoPhysicalNode.h>
39
40 AliT0CalibData* AliT0Parameters::fgCalibData = 0;
41 AliT0CalibData* AliT0Parameters::fgLookUp = 0;
42 AliT0CalibData* AliT0Parameters::fgSlewCorr =0;
43 //====================================================================
44 ClassImp(AliT0Parameters)
45 #if 0
46   ; // This is here to keep Emacs for indenting the next line
47 #endif
48
49 //____________________________________________________________________
50 AliT0Parameters* AliT0Parameters::fgInstance = 0;
51 //____________________________________________________________________
52 AliT0Parameters* 
53 AliT0Parameters::Instance() 
54 {
55   // Get static instance 
56   if (!fgInstance) fgInstance = new AliT0Parameters;
57   return fgInstance;
58 }
59
60 //____________________________________________________________________
61 AliT0Parameters::AliT0Parameters()
62   :fIsInit(kFALSE),
63    fPh2Mip(0),fmV2Mip(0),
64    fChannelWidth(0),fmV2Channel(0),
65    fQTmin(0),fQTmax(0),
66    fSlewingLED(),fSlewingRec(),
67    fPMTeff(),
68    fTimeDelayLED(0),fTimeDelayCFD(0),fTimeDelayTVD(0),
69    fCalibentry(), fLookUpentry(),fSlewCorr()
70 {
71   // Default constructor 
72
73   for (Int_t ipmt=0; ipmt<24; ipmt++)
74     {
75       SetSlewingLED(ipmt);
76       SetSlewingRec(ipmt);
77       SetWalk(ipmt);
78       SetPh2Mip();      
79       SetmV2Mip();      
80       SetChannelWidth();
81       SetmV2channel();
82       SetQTmin();
83       SetQTmax();
84       SetPMTeff(ipmt);
85
86    }
87   SetTimeDelayTVD();
88   SetZposition();
89   SetNumberOfTRMs(2);
90   
91 }
92
93 //__________________________________________________________________
94 void
95 AliT0Parameters::Init()
96 {
97   // Initialize the parameters manager.  We need to get stuff from the
98   // CDB here. 
99   //   if (fIsInit) return;
100   
101
102   AliCDBStorage *stor =AliCDBManager::Instance()->GetStorage("local://$ALICE_ROOT");
103   //time equalizing
104   AliCDBEntry* fCalibentry  = stor->Get("T0/Calib/TimeDelay",0);
105   if (fCalibentry)
106    fgCalibData  = (AliT0CalibData*)fCalibentry->GetObject();
107   else 
108     AliError(" ALARM !!!! No time delays in CDB "); 
109  //slewing correction
110   AliCDBEntry* fSlewCorr  = stor->Get("T0/Calib/Slewing_Walk",0);
111   if (fSlewCorr){
112     fgSlewCorr  = (AliT0CalibData*)fSlewCorr->GetObject();
113   }
114   fLookUpentry  = stor->Get("T0/Calib/LookUp_Table",0);
115   if (fLookUpentry){
116     fgLookUp  = (AliT0CalibData*)fLookUpentry->GetObject();
117   }
118   else {
119   const char * filename = gSystem->ExpandPathName("$ALICE_ROOT/T0/lookUpTable.txt");
120   ifstream inFile(filename);
121   fgLookUp->ReadAsciiLookup(filename);
122   }
123
124   fIsInit = kTRUE;
125 }
126
127
128 //__________________________________________________________________
129 Float_t
130 AliT0Parameters::GetTimeDelayLED(Int_t ipmt) 
131 {
132   // return time delay for LED channel
133   // 
134   if (!fCalibentry) {
135     fTimeDelayLED = 0;
136     return  fTimeDelayLED;
137   } 
138   return fgCalibData ->GetTimeDelayLED(ipmt);
139 }
140 //__________________________________________________________________
141 Float_t
142 AliT0Parameters::GetTimeDelayCFD(Int_t ipmt) 
143 {
144   // return time delay for CFD channel
145    // 
146   if (!fCalibentry) 
147     {
148       fTimeDelayCFD = 1000+ipmt*100;
149       return fTimeDelayCFD;
150     }
151    
152   return fgCalibData->GetTimeDelayCFD(ipmt);
153 }
154
155 //__________________________________________________________________
156
157 void 
158 AliT0Parameters::SetSlewingLED(Int_t ipmt)
159 {
160   //  Set Slweing Correction for LED channel 
161      Float_t mv[23] = {25, 30,40,60, 80,100,150,200,250,300,
162                        400,500,600,800,1000,1500, 2000, 3000, 4000, 5500,
163                        6000, 7000,8000};
164       Float_t y[23] = {5044, 4719, 3835, 3224, 2847, 2691,2327, 2067, 1937, 1781,
165                        1560, 1456 ,1339, 1163.5, 1027, 819, 650, 520, 370.5, 234,
166                        156, 78, 0};
167       
168       TGraph* gr = new TGraph(23,mv,y);
169       fSlewingLED.AddAtAndExpand(gr,ipmt);
170   }
171 //__________________________________________________________________
172
173 Float_t AliT0Parameters::GetSlewingLED(Int_t ipmt, Float_t mv) const
174 {
175   if (!fCalibentry) {
176     return ((TGraph*)fSlewingLED.At(ipmt))->Eval(mv); 
177   } 
178   return fgCalibData->GetSlewingLED(ipmt, mv) ;
179 }
180
181
182 //__________________________________________________________________
183
184 TGraph *AliT0Parameters::GetSlew(Int_t ipmt) const
185 {
186   if (!fCalibentry) {
187     return  (TGraph*)fSlewingLED.At(ipmt); 
188   } 
189   return fgCalibData -> GetSlew(ipmt) ;
190 }
191
192 //__________________________________________________________________
193
194
195 void 
196 AliT0Parameters::SetSlewingRec(Int_t ipmt)
197 {
198   //  Set Slweing Correction for LED channel 
199       Float_t mv[23] = {25, 30, 40,60, 80,100,150,200,250,300,
200                         400,500,600,800,1000,1500, 2000, 3000, 4000, 5500,
201                         6000, 7000,8000};
202       Float_t y[23] = {5044, 4719, 3835, 3224, 2847, 2691,2327, 2067, 1937, 1781, 
203                        1560, 1456 ,1339, 1163.5, 1027, 819, 650, 520, 370.5, 234, 
204                        156, 78, 0};
205       Float_t y1[23], mv1[23];
206       for (Int_t i=0; i<23; i++){
207         y1[i] = y[22-i]; mv1[i] = mv[22-i];}
208
209       TGraph* gr = new TGraph(23,y1,mv1);
210       fSlewingRec.AddAtAndExpand(gr,ipmt);
211
212 }
213 //__________________________________________________________________
214
215 Float_t AliT0Parameters::GetSlewingRec(Int_t ipmt, Float_t mv) const
216 {
217   if (!fCalibentry) {
218     return ((TGraph*)fSlewingRec.At(ipmt))->Eval(mv); 
219   } 
220   return fgCalibData -> GetSlewingRec(ipmt, mv) ;
221 }
222
223 //__________________________________________________________________
224
225 TGraph *AliT0Parameters::GetSlewRec(Int_t ipmt) const
226 {
227   if (!fCalibentry) {
228     return  (TGraph*)fSlewingRec.At(ipmt); 
229   } 
230   return fgCalibData -> GetSlewRec(ipmt) ;
231 }
232
233
234 //________________________________________________________________
235 void AliT0Parameters::SetWalk(Int_t ipmt)
236 {
237
238  Int_t mv, ps; 
239   Int_t x[70000], y[70000], index[70000];
240   Float_t time[10000],amplitude[10000];
241   string buffer;
242   Bool_t down=false;
243   
244   const char * filename = gSystem->ExpandPathName("$ALICE_ROOT/T0/data/CFD-Amp.txt");
245   ifstream inFile(filename);
246   //  if(!inFile) AliError(Form("Cannot open file %s !",filename));
247   
248   Int_t i=0;
249   while(getline(inFile,buffer)){
250     inFile >> ps >> mv;
251
252     x[i]=ps; y[i]=mv;
253     i++;
254   }
255   inFile.close();
256  
257   TMath::Sort(i, y, index,down);
258   Int_t amp=0, iin=0, isum=0, sum=0;
259   Int_t ind=0;
260   for (Int_t ii=0; ii<i; ii++)
261     {
262       ind=index[ii];
263       if(y[ind] == amp)
264         {
265           sum +=x[ind];
266           iin++;
267         }
268       else
269         {
270           if(iin>0)
271             time[isum] = Float_t (sum/(iin));
272           else
273             time[isum] =Float_t (x[ind]);
274           amplitude[isum] = Float_t (amp);
275           amp=y[ind];
276           //      cout<<ii<<" "<<ind<<" "<<y[ind]<<" "<<x[ind]<<" iin "<<iin<<" mean "<<time[isum]<<" amp "<< amplitude[isum]<<" "<<isum<<endl;
277           iin=0;
278           isum++;
279           sum=0;
280         }
281
282
283     }
284
285   inFile.close();
286
287    TGraph* gr = new TGraph(isum, amplitude, time);
288   fWalk.AddAtAndExpand(gr,ipmt);
289   
290   
291 }
292 //__________________________________________________________________
293
294 TGraph *AliT0Parameters::GetWalk(Int_t ipmt) const
295 {
296   if (!fCalibentry) {
297     return  (TGraph*)fWalk.At(ipmt); 
298   } 
299   return fgCalibData -> GetWalk(ipmt) ;
300 }
301
302 //__________________________________________________________________
303
304 Float_t AliT0Parameters::GetWalkVal(Int_t ipmt, Float_t mv) const
305 {
306   if (!fCalibentry) {
307     return ((TGraph*)fWalk.At(ipmt))->Eval(mv); 
308   } 
309   return fgCalibData -> GetWalkVal(ipmt, mv) ;
310 }
311
312
313 //__________________________________________________________________
314 void 
315 AliT0Parameters::SetPMTeff(Int_t ipmt)
316 {
317   Float_t lambda[50];
318   Float_t eff[50 ] = {0,        0,       0.23619,  0.202909, 0.177913, 
319                     0.175667, 0.17856, 0.190769, 0.206667, 0.230286,
320                     0.252276, 0.256267,0.26,     0.27125,  0.281818,
321                     0.288118, 0.294057,0.296222, 0.301622, 0.290421, 
322                     0.276615, 0.2666,  0.248,    0.23619,  0.227814, 
323                     0.219818, 0.206667,0.194087, 0.184681, 0.167917, 
324                     0.154367, 0.1364,  0.109412, 0.0834615,0.0725283, 
325                     0.0642963,0.05861, 0.0465,   0.0413333,0.032069, 
326                     0.0252203,0.02066, 0.016262, 0.012,    0.00590476,
327                     0.003875, 0.00190, 0,        0,        0          } ;
328   for (Int_t i=0; i<50; i++) lambda[i]=200+10*i; 
329
330   TGraph* gr = new TGraph(50,lambda,eff);
331   fPMTeff.AddAtAndExpand(gr,ipmt);
332 }
333 //________________________________________________________________
334
335 Int_t 
336 AliT0Parameters::GetChannel(Int_t trm,  Int_t tdc, Int_t chain, Int_t channel)
337 {
338
339   
340   AliT0LookUpKey * lookkey;  //= new AliT0LookUpKey();
341   AliT0LookUpValue * lookvalue= new AliT0LookUpValue(trm,tdc,chain,channel);
342     
343    lookkey = (AliT0LookUpKey*) fgLookUp->GetMapLookup()->GetValue((TObject*)lookvalue);
344   if (!lookkey ) {
345     cout<<" no such address "<<endl; return -1;
346   }
347   
348
349   //cout<<"AliT0Parameters:: key "<<lookkey->GetKey()<<endl;
350   return lookkey->GetKey();
351   
352
353 }
354 //__________________________________________________________________
355 Int_t
356 AliT0Parameters::GetNumberOfTRMs() 
357 {
358   // return number of trms
359   // 
360   if (!fgLookUp) {
361     fNumberOfTRMs = 2;
362     return  fNumberOfTRMs;
363   } 
364   return  fgLookUp ->GetNumberOfTRMs();
365 }
366 //________________________________________________________________________________
367 Double_t AliT0Parameters::GetZPosition(const char* symname){
368 // Get the global z coordinate of the given T0 alignable volume
369 //
370   Double_t *tr;
371   
372   cout<<symname<<endl;
373   TGeoPNEntry *pne = gGeoManager->GetAlignableEntry(symname);
374   if (!pne) return 0;
375   
376
377   TGeoPhysicalNode *pnode = pne->GetPhysicalNode();
378   if(pnode){
379           TGeoHMatrix* hm = pnode->GetMatrix();
380            tr = hm->GetTranslation();
381   }else{
382           const char* path = pne->GetTitle();
383           if(!gGeoManager->cd(path)){
384                   AliErrorClass(Form("Volume path %s not valid!",path));
385                   return 0;
386           }
387          tr = gGeoManager->GetCurrentMatrix()->GetTranslation();
388   }
389   return tr[2];
390
391 }
392