Put 0.1 as minimal value of the gas gain (Raphaelle)
[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 "AliT0.h"
28 #include "AliLog.h"               
29 #include "AliT0Parameters.h"      
30 #include "AliT0CalibData.h"   
31 #include "AliT0CalibWalk.h"   
32 #include "AliT0CalibTimeEq.h"   
33 #include "AliT0CalibLatency.h"   
34 #include "AliT0LookUpKey.h"
35 #include "AliT0LookUpValue.h"
36 #include <AliCDBManager.h>        
37 #include <AliCDBEntry.h>          
38 #include <AliCDBStorage.h>  
39 #include <TMath.h>
40 #include <TSystem.h>
41 //#include <Riostream.h>
42 #include <TGeoManager.h>
43 #include <TGeoPhysicalNode.h>
44 #include <TGeoMatrix.h>
45 #include <AliGeomManager.h>
46
47 AliT0CalibTimeEq* AliT0Parameters::fgCalibData = 0;
48 AliT0CalibData* AliT0Parameters::fgLookUp = 0;
49 AliT0CalibWalk* AliT0Parameters::fgSlewCorr =0;
50 AliT0CalibLatency *AliT0Parameters::fgLatency=0;
51 //====================================================================
52 ClassImp(AliT0Parameters)
53 #if 0
54   ; // This is here to keep Emacs for indenting the next line
55 #endif
56
57 //____________________________________________________________________
58 AliT0Parameters* AliT0Parameters::fgInstance = 0;
59 //____________________________________________________________________
60 AliT0Parameters* AliT0Parameters::Instance() 
61 {
62   // Get static instance 
63   if (!fgInstance) {
64     fgInstance = new AliT0Parameters;
65   }
66   return fgInstance;
67 }
68
69 //____________________________________________________________________
70 AliT0Parameters::AliT0Parameters()
71   :fIsInit(kFALSE),
72    fPh2Mip(0),fmV2Mip(0),
73    fChannelWidth(0),fmV2Channel(0),
74    fQTmin(0),fQTmax(0),
75    fAmpLEDRec(0), 
76    fPMTeff(),
77    fWalk(0),
78    fQTC(0),
79    fAmpLED(0),
80    fTimeDelayCFD(0), 
81  //  fTimeV0(0), 
82    fTimeDelayTVD(0),
83    fMeanT0(512),
84    fMeanVertex(0),
85    fLatencyHPTDC(0),
86    fLatencyL1(0),
87    fLatencyL1A(0),
88    fLatencyL1C(0),
89    fLookUp(0),
90    fNumberOfTRMs(2),
91    fCalibentry(), 
92    fLookUpentry(),
93    fSlewCorr(),
94    fLatency()
95   
96 {
97   // Default constructor 
98   for (Int_t ipmt=0; ipmt<24; ipmt++)
99     {
100       SetPh2Mip();      
101       SetmV2Mip();      
102       SetChannelWidth();
103       SetmV2channel();
104       SetQTmin();
105       SetQTmax();
106       SetPMTeff(ipmt);
107     }
108   SetTimeDelayTVD();
109   SetZposition();
110     
111 }
112
113 //__________________________________________________________________
114 void
115 AliT0Parameters::Init()
116 {
117   // Initialize the parameters manager.  We need to get stuff from the
118   // CDB here. 
119    if (fIsInit) return;
120
121    AliCDBManager *stor =AliCDBManager::Instance();
122    //time equalizing
123    fCalibentry  = stor->Get("T0/Calib/TimeDelay");
124    if (fCalibentry)
125      fgCalibData  = (AliT0CalibTimeEq*)fCalibentry->GetObject();
126    else {
127          AliFatal(" ALARM !!!! No time delays in CDB "); 
128      fIsInit = kFALSE;
129      return;
130    }
131  //slewing correction
132   fSlewCorr  = stor->Get("T0/Calib/Slewing_Walk");
133   if (fSlewCorr){
134     fgSlewCorr  = (AliT0CalibWalk*)fSlewCorr->GetObject();
135   }
136   else {
137       AliFatal(" ALARM !!!! No slewing correction in CDB "); 
138     fIsInit = kFALSE;
139     return;
140   }
141   //lookup table
142   fLookUpentry  = stor->Get("T0/Calib/LookUp_Table");
143   if (fLookUpentry){
144     fgLookUp  = (AliT0CalibData*)fLookUpentry->GetObject();
145   }
146   else {
147      AliFatal(" ALARM !!!! No Lookup table  in CDB "); 
148     fIsInit = kFALSE;
149     return;
150   }
151   //latency
152   
153  fLatency  = stor->Get("T0/Calib/Latency");
154   if (fLatency){
155     fgLatency  = (AliT0CalibLatency*)fLatency->GetObject();
156   }
157   else {
158      AliWarning(" !!! no latency  in CDB "); 
159     return;
160   }
161   
162 fIsInit = kTRUE;
163 }
164
165
166 //__________________________________________________________________
167
168 void AliT0Parameters::InitIfOnline()
169 {
170 // should be used in online
171 // for switching to this one should write
172   // AliT0RawReader myrawreader(rawReader);
173 //      myrawreader.SetOnlineMode(kTRUE);
174
175   if (fIsInit) return;
176    //standart configuration (used for simulation)
177    //Int_t trm=0; Int_t tdc=0; Int_t chain=0; Int_t channel=0;
178   // configuration for test Jun07.
179    fgLookUp = new AliT0CalibData("T0");
180
181   fNumberOfTRMs = 1;
182  fgLookUp-> SetNumberOfTRMs(fNumberOfTRMs);
183   Int_t trm=7; Int_t tdc=0; Int_t chain=0; Int_t channel=0;
184   for (Int_t ik=0; ik<105; ik++)
185         {
186          AliT0LookUpKey * lookkey= new AliT0LookUpKey();
187          AliT0LookUpValue * lookvalue= new AliT0LookUpValue();
188
189
190           lookvalue->SetTRM(trm);
191           lookvalue->SetTDC(tdc);
192           lookvalue->SetChain(chain);
193           lookvalue->SetChannel(channel);
194           lookkey->SetKey(ik);
195           fgLookUp->GetMapLookup()->Add((TObject*)lookvalue,(TObject*)lookkey); 
196           if (channel<6) channel +=2;
197           else {channel = 0; tdc++;}
198           if(ik==56) { tdc=0; channel=0; chain = 1;}
199
200        }
201   
202   fIsInit=kTRUE;
203 }
204 //__________________________________________________________________
205 Float_t
206 AliT0Parameters::GetTimeDelayCFD(Int_t ipmt) 
207   {
208   // return time delay for CFD channel
209    // 
210   if (!fCalibentry) 
211     {
212       fTimeDelayCFD = 1000+ipmt*100;
213       return fTimeDelayCFD;
214     }
215    
216   return fgCalibData->GetTimeEq(ipmt);
217 }
218
219 //__________________________________________________________________
220 Float_t
221 AliT0Parameters::GetLatencyHPTDC() 
222   {
223   // return LatencyHPTDC for CFD channel
224   if (!fLatency) 
225     {
226       fLatencyHPTDC=9000.;
227       return fLatencyHPTDC;
228     }
229    
230   return fgLatency->GetLatencyHPTDC();
231 }
232 //__________________________________________________________________
233 Float_t
234 AliT0Parameters::GetLatencyL1() 
235   {
236   // return time delay for CFD channel
237    
238   return fgLatency->GetLatencyL1();
239 }
240
241 //__________________________________________________________________
242 Float_t
243 AliT0Parameters::GetLatencyL1A() 
244   {
245   // return time delay for CFD channel
246    
247   return fgLatency->GetLatencyL1A();
248 }
249
250 //__________________________________________________________________
251 Float_t
252 AliT0Parameters::GetLatencyL1C() 
253   {
254   // return time delay for CFD channel
255    
256   return fgLatency->GetLatencyL1C();
257 }
258 //__________________________________________________________________
259
260 Float_t
261 AliT0Parameters:: GetMeanVertex()
262
263   if (!fCalibentry) 
264     {
265       fMeanVertex=0;
266       return fMeanVertex;
267     }
268    
269   return fgCalibData->GetMeanVertex();
270 }
271 //__________________________________________________________________
272
273 TGraph *AliT0Parameters::GetAmpLEDRec(Int_t ipmt) const
274 {
275    if (!fSlewCorr) {
276      AliError("No slewing correction is available!");
277      return  (TGraph*)fAmpLEDRec.At(ipmt); 
278   } 
279   return fgSlewCorr -> GetAmpLEDRec(ipmt) ;
280 }
281
282 //__________________________________________________________________
283
284 TGraph *AliT0Parameters::GetWalk(Int_t ipmt) const
285 {
286   if (!fSlewCorr) {
287     AliError("No walk correction is available!");
288     return  (TGraph*)fWalk.At(ipmt); 
289   } 
290   return fgSlewCorr -> GetWalk(ipmt) ;
291 }
292
293 //__________________________________________________________________
294
295 TGraph *AliT0Parameters::GetQTC(Int_t ipmt) const
296 {
297   if (!fSlewCorr) {
298     AliError("No walk correction is available!");
299     //    return  (TGraph*)fQTC.At(ipmt); 
300    return  0; 
301   } 
302   return fgSlewCorr -> GetQTC(ipmt) ;
303 }
304
305 //__________________________________________________________________
306 TGraph *AliT0Parameters::GetAmpLED(Int_t ipmt) const
307 {
308   if (!fSlewCorr) {
309     AliError("No walk correction is available!");
310     //    return  (TGraph*)fQTC.At(ipmt); 
311    return  0; 
312   } 
313   return fgSlewCorr -> GetAmpLED(ipmt) ;
314 }
315
316 //__________________________________________________________________
317 void 
318 AliT0Parameters::SetPMTeff(Int_t ipmt)
319 {
320   Float_t lambda[50];
321   Float_t eff[50 ] = {0,        0,       0.23619,  0.202909, 0.177913, 
322                     0.175667, 0.17856, 0.190769, 0.206667, 0.230286,
323                     0.252276, 0.256267,0.26,     0.27125,  0.281818,
324                     0.288118, 0.294057,0.296222, 0.301622, 0.290421, 
325                     0.276615, 0.2666,  0.248,    0.23619,  0.227814, 
326                     0.219818, 0.206667,0.194087, 0.184681, 0.167917, 
327                     0.154367, 0.1364,  0.109412, 0.0834615,0.0725283, 
328                     0.0642963,0.05861, 0.0465,   0.0413333,0.032069, 
329                     0.0252203,0.02066, 0.016262, 0.012,    0.00590476,
330                     0.003875, 0.00190, 0,        0,        0          } ;
331   for (Int_t i=0; i<50; i++) lambda[i]=200+10*i; 
332
333   TGraph* gr = new TGraph(50,lambda,eff);
334   fPMTeff.AddAtAndExpand(gr,ipmt);
335 }
336 //________________________________________________________________
337
338 Int_t 
339 AliT0Parameters::GetChannel(Int_t trm,  Int_t tdc, Int_t chain, Int_t channel)
340 {
341
342   if (fgLookUp) {
343     AliT0LookUpValue key(trm,tdc,chain,channel);
344       AliT0LookUpKey *val = (AliT0LookUpKey*) fgLookUp->GetMapLookup()->GetValue((TObject*)&key);
345       // AliT0LookUpKey *val = (AliT0LookUpKey*) fLookUp.GetValue((TObject*)&key);
346     if (val )
347       return val->GetKey();
348     else {
349       AliWarning(Form("No such address (%d %d %d %d)!",trm,tdc,chain,channel));
350       return -1;
351     }
352   }
353   else {
354     AliError("No look up table has been loader!");
355     return -1;
356   }
357
358 }
359 //__________________________________________________________________
360 TMap *AliT0Parameters::GetMapLookup()
361 {
362   if (!fgLookUp){
363     cout<<" No look up table in OCDB";
364     return 0;
365   }
366   return   fgLookUp->GetMapLookup();
367 }
368 //__________________________________________________________________
369
370 Int_t
371 AliT0Parameters::GetNumberOfTRMs() 
372 {
373   // return number of trms
374   // 
375   if (!fgLookUp) {
376     //  fNumberOfTRMs = 2;
377     return  fNumberOfTRMs;
378   } 
379   return  fgLookUp ->GetNumberOfTRMs();
380 }
381 /*
382 //________________________________________________________________________________
383 Double_t AliT0Parameters::GetZPosition(const char* symname){
384 // Get the global z coordinate of the given T0 alignable volume
385 //
386   Double_t *tr = AliGeomManager::GetMatrix(symname)->GetTranslation();
387
388   return tr[2];
389 }
390 */
391 //________________________________________________________________________________
392 Double_t AliT0Parameters::GetZPosition(const char* symname){
393 // Get the global z coordinate of the given T0 alignable volume
394 //
395   Double_t *tr;
396   TGeoPNEntry *pne = gGeoManager->GetAlignableEntry(symname);
397   if (!pne) return 0;
398   
399
400   TGeoPhysicalNode *pnode = pne->GetPhysicalNode();
401   if(pnode){
402           TGeoHMatrix* hm = pnode->GetMatrix();
403            tr = hm->GetTranslation();
404   }else{
405           const char* path = pne->GetTitle();
406           if(!gGeoManager->cd(path)){
407                   AliErrorClass(Form("Volume path %s not valid!",path));
408                   return 0;
409           }
410          tr = gGeoManager->GetCurrentMatrix()->GetTranslation();
411   }
412   return tr[2];
413
414 }
415 //________________________________________________________________________________
416
417 Double_t AliT0Parameters::GetZPositionShift(const char* symname)
418 {
419 // Get the global z coordinate of the given T0 alignable volume
420 //
421   Double_t *tr = AliGeomManager::GetMatrix(symname)->GetTranslation();
422
423   TGeoHMatrix origmat;
424   AliGeomManager::GetOrigGlobalMatrix(symname,origmat);
425   Double_t *otr = origmat.GetTranslation();
426
427   return (tr[2]-otr[2]);
428 }
429