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