Updates in order to enable the '2D' PID for the TRD developed by Daniel Lohner.
[u/mrichter/AliRoot.git] / TRD / AliTRDcalibDB.cxx
CommitLineData
3551db50 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// Class providing the calibration parameters by accessing the CDB //
21// //
2745a409 22// Request an instance with AliTRDcalibDB::Instance() //
3551db50 23// If a new event is processed set the event number with SetRun //
24// Then request the calibration data //
25// //
2745a409 26// Author: //
27// Jan Fiete Grosse-Oetringhaus (Jan.Fiete.Grosse-Oetringhaus@cern.ch) //
28// //
3551db50 29///////////////////////////////////////////////////////////////////////////////
30
a7ac01d2 31#include <TClonesArray.h>
e232d349 32#include <TObjArray.h>
3551db50 33
2745a409 34#include "AliCDBManager.h"
2745a409 35#include "AliCDBEntry.h"
36#include "AliLog.h"
3551db50 37
51a0ce25 38#include "AliTRDPIDReference.h"
3551db50 39#include "AliTRDcalibDB.h"
a9e22145 40#include "AliTRDtrapConfig.h"
41#include "AliTRDtrapConfigHandler.h"
eda91732 42#include "AliTRDCommonParam.h"
3551db50 43
7754cd1f 44#include "Cal/AliTRDCalROC.h"
7754cd1f 45#include "Cal/AliTRDCalPad.h"
46#include "Cal/AliTRDCalDet.h"
e232d349 47#include "Cal/AliTRDCalDCS.h"
d6a1ec13 48#include "Cal/AliTRDCalDCSv2.h"
ea3eaa08 49#include "Cal/AliTRDCalDCSFEEv2.h"
720a0a16 50#include "Cal/AliTRDCalPID.h"
7754cd1f 51#include "Cal/AliTRDCalMonitoring.h"
7754cd1f 52#include "Cal/AliTRDCalChamberStatus.h"
7754cd1f 53#include "Cal/AliTRDCalPadStatus.h"
54#include "Cal/AliTRDCalSingleChamberStatus.h"
9dcc64cc 55#include "Cal/AliTRDCalTrkAttach.h"
ea3eaa08 56#include "Cal/AliTRDCalOnlineGainTable.h"
3551db50 57
58ClassImp(AliTRDcalibDB)
59
2745a409 60AliTRDcalibDB *AliTRDcalibDB::fgInstance = 0;
61Bool_t AliTRDcalibDB::fgTerminated = kFALSE;
3551db50 62
63//_ singleton implementation __________________________________________________
64AliTRDcalibDB* AliTRDcalibDB::Instance()
65{
66 //
67 // Singleton implementation
68 // Returns an instance of this class, it is created if neccessary
63a700c6 69 //
3551db50 70
6d50f529 71 if (fgTerminated != kFALSE) {
3551db50 72 return 0;
6d50f529 73 }
3551db50 74
6d50f529 75 if (fgInstance == 0) {
3551db50 76 fgInstance = new AliTRDcalibDB();
6d50f529 77 }
e254cad1 78
3551db50 79 return fgInstance;
4e009ce4 80
3551db50 81}
82
2745a409 83//_____________________________________________________________________________
3551db50 84void AliTRDcalibDB::Terminate()
85{
86 //
87 // Singleton implementation
6bf5f0ce 88 // Deletes the instance of this class and sets the terminated flag,
89 // instances cannot be requested anymore
3551db50 90 // This function can be called several times.
91 //
92
93 fgTerminated = kTRUE;
94
6d50f529 95 if (fgInstance != 0) {
3551db50 96 delete fgInstance;
97 fgInstance = 0;
98 }
2745a409 99
3551db50 100}
101
102//_____________________________________________________________________________
103AliTRDcalibDB::AliTRDcalibDB()
2745a409 104 :TObject()
105 ,fRun(-1)
6d50f529 106 ,fPRFsmp(0)
107 ,fPRFbin(0)
108 ,fPRFlo(0)
109 ,fPRFhi(0)
110 ,fPRFwid(0)
111 ,fPRFpad(0)
9dcc64cc 112 ,fPIDResponse(NULL)
ea3eaa08 113 ,fOnlineGainTableID(0)
a9e22145 114 ,fTrapConfig(0x0)
f16844ef 115 ,fTrapConfigName("")
116 ,fTrapConfigVersion("")
3551db50 117{
118 //
2745a409 119 // Default constructor
3551db50 120 //
2745a409 121 // TODO Default runnumber is set to 0, this should be changed later
122 // to an invalid value (e.g. -1) to prevent
3551db50 123 // TODO invalid calibration data to be used.
2745a409 124 //
125
95867fd1 126 for (Int_t i = 0; i < kCDBCacheSize; ++i) {
2745a409 127 fCDBCache[i] = 0;
128 fCDBEntries[i] = 0;
129 }
3551db50 130
2745a409 131 // Create the sampled PRF
132 SamplePRF();
d4c6453d 133
2745a409 134}
135
136//_____________________________________________________________________________
137AliTRDcalibDB::AliTRDcalibDB(const AliTRDcalibDB &c)
138 :TObject(c)
6d50f529 139 ,fRun(-1)
140 ,fPRFsmp(0)
141 ,fPRFbin(0)
142 ,fPRFlo(0)
143 ,fPRFhi(0)
144 ,fPRFwid(0)
145 ,fPRFpad(0)
9dcc64cc 146 ,fPIDResponse(NULL)
ea3eaa08 147 ,fOnlineGainTableID(0)
a9e22145 148 ,fTrapConfig(0x0)
f16844ef 149 ,fTrapConfigName("")
150 ,fTrapConfigVersion("")
2745a409 151{
152 //
153 // Copy constructor (not that it make any sense for a singleton...)
154 //
155
95867fd1 156 for (Int_t i = 0; i < kCDBCacheSize; ++i) {
2745a409 157 fCDBCache[i] = 0;
3551db50 158 fCDBEntries[i] = 0;
159 }
6a739e92 160
161 // Create the sampled PRF
162 SamplePRF();
2745a409 163
164}
165
166//_____________________________________________________________________________
167AliTRDcalibDB &AliTRDcalibDB::operator=(const AliTRDcalibDB &c)
168{
169 //
170 // Assignment operator (same as above ...)
171 //
172
173 if (this != &c) {
174 AliFatal("No assignment operator defined");
175 }
4e009ce4 176
2745a409 177 return *this;
178
acba9bad 179}
3551db50 180
181//_____________________________________________________________________________
182AliTRDcalibDB::~AliTRDcalibDB()
183{
184 //
185 // destructor
186 //
187
6d50f529 188 if (fPRFsmp) {
189 delete [] fPRFsmp;
190 fPRFsmp = 0;
6a739e92 191 }
ea3eaa08 192
193 if (fPIDResponse) {
194 delete fPIDResponse;
195 fPIDResponse = 0x0;
196 }
6a739e92 197
3551db50 198 Invalidate();
2745a409 199
acba9bad 200}
3551db50 201
63a700c6 202//_caching functions____________________________________________________________
95867fd1 203const TObject *AliTRDcalibDB::GetCachedCDBObject(Int_t id)
63a700c6 204{
2745a409 205 //
206 // Retrieves a cdb object with the given id. The objects are cached as
207 // long as the run number is not changed.
208 //
209 // Put together the available objects here by using the lines
210 // a) For usual calibration objects:
211 // case kID<Name> :
212 // return CacheCDBEntry(kID<Name>,"TRD/Calib/<Path>");
213 // break;
214 // See function CacheCDBEntry for details.
215 // and
216 // b) For calibration data which depends on two objects: One containing
217 // a value per detector and one the local fluctuations per pad:
218 // case kID<Name> :
219 // return CacheMergeCDBEntry(kID<Name>,"TRD/Calib/<padPath>","TRD/Calib/<chamberPath>");
220 // break;
221 // See function CacheMergeCDBEntry for details.
222 //
63a700c6 223
6d50f529 224 switch (id) {
2745a409 225
226 // Parameters defined per pad and chamber
227 case kIDVdriftPad :
6d50f529 228 return CacheCDBEntry(kIDVdriftPad ,"TRD/Calib/LocalVdrift");
2745a409 229 break;
230 case kIDVdriftChamber :
6d50f529 231 return CacheCDBEntry(kIDVdriftChamber ,"TRD/Calib/ChamberVdrift");
2745a409 232 break;
eda91732 233 case kIDExBChamber :
234 return CacheCDBEntry(kIDExBChamber ,"TRD/Calib/ChamberExB");
235 break;
2745a409 236 case kIDT0Pad :
6d50f529 237 return CacheCDBEntry(kIDT0Pad ,"TRD/Calib/LocalT0");
2745a409 238 break;
239 case kIDT0Chamber :
6d50f529 240 return CacheCDBEntry(kIDT0Chamber ,"TRD/Calib/ChamberT0");
2745a409 241 break;
242 case kIDGainFactorPad :
6d50f529 243 return CacheCDBEntry(kIDGainFactorPad ,"TRD/Calib/LocalGainFactor");
2745a409 244 break;
245 case kIDGainFactorChamber :
6d50f529 246 return CacheCDBEntry(kIDGainFactorChamber ,"TRD/Calib/ChamberGainFactor");
2745a409 247 break;
ea3eaa08 248
249 case kIDOnlineGainFactor :
250 switch(GetOnlineGainTableID()) {
251 case 0:
252 // For testing purposes only !!!
253 AliInfo("No gain table name from OCDB. Use default table!");
254 return CacheCDBEntry(kIDOnlineGainFactor ,"TRD/Calib/Krypton_2011-01");
255 break;
256 case 1:
257 // Online gain table ID 1
258 return CacheCDBEntry(kIDOnlineGainFactor ,"TRD/Calib/Krypton_2011-01");
259 break;
412d07b9 260 case 2:
261 // Online gain table ID 2
262 return CacheCDBEntry(kIDOnlineGainFactor ,"TRD/Calib/Gaintbl_Uniform_FGAN0_2011-01");
263 break;
264 case 3:
265 // Online gain table ID 3
266 return CacheCDBEntry(kIDOnlineGainFactor ,"TRD/Calib/Gaintbl_Uniform_FGAN8_2011-01");
267 break;
3abf1c06 268 case 4:
269 // Online gain table ID 4
270 return CacheCDBEntry(kIDOnlineGainFactor ,"TRD/Calib/Krypton_2011-02");
271 break;
4a05be5f 272 case 5:
273 // Online gain table ID 5
274 return CacheCDBEntry(kIDOnlineGainFactor ,"TRD/Calib/Krypton_2011-03");
275 break;
276 case 6:
277 // Online gain table ID 6
278 return CacheCDBEntry(kIDOnlineGainFactor ,"TRD/Calib/Gaintbl_Uniform_FGAN0_2012-01");
279 break;
280 case 7:
281 // Online gain table ID 7
282 return CacheCDBEntry(kIDOnlineGainFactor ,"TRD/Calib/Gaintbl_Uniform_FGAN8_2012-01");
283 break;
ea3eaa08 284 }
285 break;
286
df83a620 287 case kIDNoiseChamber :
ea3eaa08 288 return CacheCDBEntry(kIDNoiseChamber ,"TRD/Calib/DetNoise");
df83a620 289 break;
290 case kIDNoisePad :
ea3eaa08 291 return CacheCDBEntry(kIDNoisePad ,"TRD/Calib/PadNoise");
df83a620 292 break;
293
2745a409 294 // Parameters defined per pad
295 case kIDPRFWidth :
6d50f529 296 return CacheCDBEntry(kIDPRFWidth ,"TRD/Calib/PRFWidth");
2745a409 297 break;
298
299 // Status values
2745a409 300 case kIDChamberStatus :
6d50f529 301 return CacheCDBEntry(kIDChamberStatus ,"TRD/Calib/ChamberStatus");
2745a409 302 break;
2745a409 303 case kIDPadStatus :
6d50f529 304 return CacheCDBEntry(kIDPadStatus ,"TRD/Calib/PadStatus");
2745a409 305 break;
306
307 // Global parameters
308 case kIDMonitoringData :
6d50f529 309 return CacheCDBEntry(kIDMonitoringData ,"TRD/Calib/MonitoringData");
2745a409 310 break;
aa617684 311 case kIDFEE :
312 return CacheCDBEntry(kIDFEE ,"TRD/Calib/FEE");
2745a409 313 break;
a9e22145 314 case kIDTrapConfig :
315 return CacheCDBEntry(kIDFEE ,"TRD/Calib/TrapConfig");
316 break;
e232d349 317 case kIDDCS :
5f481838 318 return CacheCDBEntry(kIDDCS ,"TRD/Calib/DCS");
e232d349 319 break;
44dbae42 320 case kIDPIDNN :
321 return CacheCDBEntry(kIDPIDNN ,"TRD/Calib/PIDNN");
ea3eaa08 322 break;
2745a409 323 case kIDPIDLQ :
6d50f529 324 return CacheCDBEntry(kIDPIDLQ ,"TRD/Calib/PIDLQ");
2745a409 325 break;
9dcc64cc 326 case kIDPIDLQ1D:
327 return CacheCDBEntry(kIDPIDLQ1D ,"TRD/Calib/PIDLQ1D");
328 break;
a7ac01d2 329 case kIDRecoParam :
9dcc64cc 330 return CacheCDBEntry(kIDRecoParam ,"TRD/Calib/RecoParam");
331 break;
332 case kIDAttach :
333 return CacheCDBEntry(kIDAttach ,"TRD/Calib/TrkAttach");
a7ac01d2 334 break;
e2a1c98b 335 case kIDPHQ :
336 return CacheCDBEntry(kIDPHQ ,"TRD/Calib/PHQ");
337 break;
2745a409 338 }
339
340 return 0;
341
63a700c6 342}
343
344//_____________________________________________________________________________
95867fd1 345AliCDBEntry *AliTRDcalibDB::GetCDBEntry(const char *cdbPath)
63a700c6 346{
347 //
348 // Retrieves an entry with path <cdbPath> from the CDB.
349 //
350
95867fd1 351 AliCDBEntry *entry = AliCDBManager::Instance()->Get(cdbPath,fRun);
2745a409 352 if (!entry) {
a7ac01d2 353 AliError(Form("Failed to get entry: %s",cdbPath));
63a700c6 354 return 0;
355 }
356
63a700c6 357 return entry;
2745a409 358
63a700c6 359}
360
361//_____________________________________________________________________________
95867fd1 362const TObject *AliTRDcalibDB::CacheCDBEntry(Int_t id, const char *cdbPath)
63a700c6 363{
364 //
365 // Caches the entry <id> with cdb path <cdbPath>
366 //
d6a1ec13 367
2745a409 368 if (!fCDBCache[id]) {
63a700c6 369 fCDBEntries[id] = GetCDBEntry(cdbPath);
95867fd1 370 if (fCDBEntries[id]) {
63a700c6 371 fCDBCache[id] = fCDBEntries[id]->GetObject();
95867fd1 372 }
d6a1ec13 373 }
374
63a700c6 375 return fCDBCache[id];
ea3eaa08 376
63a700c6 377}
378
3551db50 379//_____________________________________________________________________________
380void AliTRDcalibDB::SetRun(Long64_t run)
381{
382 //
7754cd1f 383 // Sets current run number. Calibration data is read from the corresponding file.
3551db50 384 // When the run number changes the caching is invalidated.
385 //
7754cd1f 386
6d50f529 387 if (fRun == run) {
3551db50 388 return;
6d50f529 389 }
7754cd1f 390
3551db50 391 fRun = run;
95867fd1 392
3551db50 393 Invalidate();
2745a409 394
3551db50 395}
7754cd1f 396
3551db50 397//_____________________________________________________________________________
398void AliTRDcalibDB::Invalidate()
399{
400 //
401 // Invalidates cache (when run number is changed).
402 //
403
95867fd1 404 for (Int_t i = 0; i < kCDBCacheSize; ++i) {
2745a409 405 if (fCDBEntries[i]) {
406 if (AliCDBManager::Instance()->GetCacheFlag() == kFALSE) {
11f5dd43 407 if ((fCDBEntries[i]->IsOwner() == kFALSE) &&
408 (fCDBCache[i])) {
e254cad1 409 delete fCDBCache[i];
2745a409 410 }
e254cad1 411 delete fCDBEntries[i];
412 }
3551db50 413 fCDBEntries[i] = 0;
2745a409 414 fCDBCache[i] = 0;
3551db50 415 }
416 }
2745a409 417
ea3eaa08 418 fOnlineGainTableID = 0;
419
df83a620 420}
ea3eaa08 421
df83a620 422//_____________________________________________________________________________
423Float_t AliTRDcalibDB::GetNoise(Int_t det, Int_t col, Int_t row)
424{
425 //
426 // Returns the noise level in ADC counts for the given pad.
427 //
428
429 const AliTRDCalPad *calPad = dynamic_cast<const AliTRDCalPad *>
430 (GetCachedCDBObject(kIDNoisePad));
431 if (!calPad) {
432 return -1;
433 }
434
435 AliTRDCalROC *roc = calPad->GetCalROC(det);
436 if (!roc) {
437 return -1;
438 }
439
440 const AliTRDCalDet *calChamber = dynamic_cast<const AliTRDCalDet *>
441 (GetCachedCDBObject(kIDNoiseChamber));
442 if (!calChamber) {
443 return -1;
444 }
445
446 return calChamber->GetValue(det) * roc->GetValue(col,row);
447
448}
449
450//_____________________________________________________________________________
451AliTRDCalROC *AliTRDcalibDB::GetNoiseROC(Int_t det)
452{
453 //
454 // Returns the Vdrift calibration object for a given ROC
455 // containing one number per pad
456 //
457
458 const AliTRDCalPad *calPad = dynamic_cast<const AliTRDCalPad *>
459 (GetCachedCDBObject(kIDNoisePad));
460 if (!calPad) {
461 return 0;
462 }
463
464 AliTRDCalROC *roc = calPad->GetCalROC(det);
465 if (!roc) {
466 return 0;
467 }
468 else {
469 return roc;
470 }
471
472}
473
474//_____________________________________________________________________________
475const AliTRDCalDet *AliTRDcalibDB::GetNoiseDet()
476{
477 //
478 // Returns the Vdrift calibration object
479 // containing one number per detector
480 //
481
482 const AliTRDCalDet *calChamber = dynamic_cast<const AliTRDCalDet *>
483 (GetCachedCDBObject(kIDNoiseChamber));
484 if (!calChamber) {
485 return 0;
486 }
487 else {
488 return calChamber;
489 }
490
3551db50 491}
492
3551db50 493//_____________________________________________________________________________
494Float_t AliTRDcalibDB::GetVdrift(Int_t det, Int_t col, Int_t row)
495{
496 //
497 // Returns the drift velocity for the given pad.
498 //
7754cd1f 499
95867fd1 500 const AliTRDCalPad *calPad = dynamic_cast<const AliTRDCalPad *>
6d50f529 501 (GetCachedCDBObject(kIDVdriftPad));
502 if (!calPad) {
3551db50 503 return -1;
6d50f529 504 }
3551db50 505
95867fd1 506 AliTRDCalROC *roc = calPad->GetCalROC(det);
6d50f529 507 if (!roc) {
3551db50 508 return -1;
6d50f529 509 }
3551db50 510
95867fd1 511 const AliTRDCalDet *calChamber = dynamic_cast<const AliTRDCalDet *>
6d50f529 512 (GetCachedCDBObject(kIDVdriftChamber));
513 if (!calChamber) {
7754cd1f 514 return -1;
6d50f529 515 }
7754cd1f 516
95867fd1 517 return calChamber->GetValue(det) * roc->GetValue(col,row);
2745a409 518
7754cd1f 519}
afb9f880 520
521//_____________________________________________________________________________
522AliTRDCalROC *AliTRDcalibDB::GetVdriftROC(Int_t det)
523{
524 //
525 // Returns the Vdrift calibration object for a given ROC
526 // containing one number per pad
527 //
528
529 const AliTRDCalPad *calPad = dynamic_cast<const AliTRDCalPad *>
530 (GetCachedCDBObject(kIDVdriftPad));
531 if (!calPad) {
532 return 0;
533 }
534
535 AliTRDCalROC *roc = calPad->GetCalROC(det);
536 if (!roc) {
537 return 0;
538 }
539 else {
540 return roc;
541 }
542
543}
544
545//_____________________________________________________________________________
546const AliTRDCalDet *AliTRDcalibDB::GetVdriftDet()
547{
548 //
549 // Returns the Vdrift calibration object
550 // containing one number per detector
551 //
552
553 const AliTRDCalDet *calChamber = dynamic_cast<const AliTRDCalDet *>
554 (GetCachedCDBObject(kIDVdriftChamber));
555 if (!calChamber) {
556 return 0;
557 }
558 else {
559 return calChamber;
560 }
561
562}
7754cd1f 563
e2a1c98b 564//_____________________________________________________________________________
565TObjArray * AliTRDcalibDB::GetPHQ()
566{
567 //
568 //return PHQ calibration object
569 //
570 TObjArray *arr = (TObjArray *) (GetCachedCDBObject(kIDPHQ));
571 return arr;
572}
573
7754cd1f 574//_____________________________________________________________________________
575Float_t AliTRDcalibDB::GetVdriftAverage(Int_t det)
576{
577 //
578 // Returns the average drift velocity for the given detector
579 //
580
95867fd1 581 const AliTRDCalDet *calDet = dynamic_cast<const AliTRDCalDet *>
6d50f529 582 (GetCachedCDBObject(kIDVdriftChamber));
583 if (!calDet) {
7754cd1f 584 return -1;
6d50f529 585 }
7754cd1f 586
587 return calDet->GetValue(det);
2745a409 588
acba9bad 589}
eda91732 590//_____________________________________________________________________________
591const AliTRDCalDet *AliTRDcalibDB::GetExBDet()
592{
593 //
594 // Returns the exB calibration object
595 // containing one number per detector
596 //
597
598 const AliTRDCalDet *calChamber = dynamic_cast<const AliTRDCalDet *> (GetCachedCDBObject(kIDExBChamber));
599
600 Double_t meanexb = 100.0;
601 if (calChamber) meanexb = calChamber->GetMean();
602 //printf("mean %f\n",meanexb);
3551db50 603
eda91732 604 if ((!calChamber) || (meanexb > 70.0)) {
605
606 const AliTRDCalDet *calChambervdrift = dynamic_cast<const AliTRDCalDet *>
607 (GetCachedCDBObject(kIDVdriftChamber));
608 if (!calChambervdrift) {
609 return 0;
610 }
611 else {
612 AliTRDCalDet *calDetExB = new AliTRDCalDet("lorentz angle tan","lorentz angle tan (detector value)");
613 for(Int_t k = 0; k < 540; k++){
614 calDetExB->SetValue(k,AliTRDCommonParam::Instance()->GetOmegaTau(calChambervdrift->GetValue(k)));
eda91732 615 }
616 return calDetExB;
617 }
618 }
619 else return calChamber;
620
621}
3551db50 622//_____________________________________________________________________________
623Float_t AliTRDcalibDB::GetT0(Int_t det, Int_t col, Int_t row)
624{
625 //
626 // Returns t0 for the given pad.
627 //
628
d4c6453d 629 const AliTRDCalPad *calPad = dynamic_cast<const AliTRDCalPad *>
630 (GetCachedCDBObject(kIDT0Pad));
6d50f529 631 if (!calPad) {
3551db50 632 return -1;
6d50f529 633 }
3551db50 634
d4c6453d 635 AliTRDCalROC *roc = calPad->GetCalROC(det);
6d50f529 636 if (!roc) {
3551db50 637 return -1;
6d50f529 638 }
3551db50 639
d4c6453d 640 const AliTRDCalDet *calChamber = dynamic_cast<const AliTRDCalDet *>
641 (GetCachedCDBObject(kIDT0Chamber));
6d50f529 642 if (!calChamber) {
7754cd1f 643 return -1;
6d50f529 644 }
7754cd1f 645
8d786fb8 646 return calChamber->GetValue(det) + roc->GetValue(col,row);
2745a409 647
7754cd1f 648}
afb9f880 649
56178ff4 650//_____________________________________________________________________________
651AliTRDCalROC *AliTRDcalibDB::GetT0ROC(Int_t det)
652{
653 //
654 // Returns the t0 calibration object for a given ROC
655 // containing one number per pad
656 //
657
658 const AliTRDCalPad *calPad = dynamic_cast<const AliTRDCalPad *>
659 (GetCachedCDBObject(kIDT0Pad));
660 if (!calPad) {
661 return 0;
662 }
663
664 AliTRDCalROC *roc = calPad->GetCalROC(det);
665 if (!roc) {
666 return 0;
667 }
668 else {
669 return roc;
670 }
671
672}
673
674//_____________________________________________________________________________
675const AliTRDCalDet *AliTRDcalibDB::GetT0Det()
676{
677 //
678 // Returns the t0 calibration object
679 // containing one number per detector
680 //
681
682 const AliTRDCalDet *calChamber = dynamic_cast<const AliTRDCalDet *>
683 (GetCachedCDBObject(kIDT0Chamber));
684 if (!calChamber) {
685 return 0;
686 }
687 else {
688 return calChamber;
689 }
690
691}
692
7754cd1f 693//_____________________________________________________________________________
694Float_t AliTRDcalibDB::GetT0Average(Int_t det)
695{
696 //
697 // Returns the average t0 for the given detector
698 //
699
5aba4f09 700 const AliTRDCalPad *calPad = dynamic_cast<const AliTRDCalPad *>
701 (GetCachedCDBObject(kIDT0Pad));
702 if (!calPad) {
703 return -1;
704 }
705
706 AliTRDCalROC *roc = calPad->GetCalROC(det);
707 if (!roc) {
708 return -1;
709 }
710
95867fd1 711 const AliTRDCalDet *calDet = dynamic_cast<const AliTRDCalDet *>
6d50f529 712 (GetCachedCDBObject(kIDT0Chamber));
713 if (!calDet) {
7754cd1f 714 return -1;
6d50f529 715 }
7754cd1f 716
4eb02ab1 717 Double_t sum = 0.0;
5aba4f09 718 for (Int_t channel = 0; channel < roc->GetNchannels(); ++channel) {
4eb02ab1 719 sum += roc->GetValue(channel);
5aba4f09 720 }
4eb02ab1 721 sum /= roc->GetNchannels();
722 sum += calDet->GetValue(det);
723 return sum;
2745a409 724
acba9bad 725}
3551db50 726
ea3eaa08 727//_____________________________________________________________________________
728AliTRDCalOnlineGainTableROC* AliTRDcalibDB::GetOnlineGainTableROC(Int_t det)
729{
730 //
731 // Returns the online gain factor table for a given ROC.
732 //
c36ddf52 733
734 if (!HasOnlineFilterGain()) {
735 return 0x0;
736 }
ea3eaa08 737
738 const AliTRDCalOnlineGainTable *calOnline
739 = dynamic_cast<const AliTRDCalOnlineGainTable *>
740 (GetCachedCDBObject(kIDOnlineGainFactor));
741 if (!calOnline) {
742 return 0x0;
743 }
744
745 return calOnline->GetGainTableROC(det);
746
747}
748
749//_____________________________________________________________________________
750Float_t AliTRDcalibDB::GetOnlineGainFactor(Int_t det, Int_t col, Int_t row)
751{
752 //
753 // Returns the online gain factor for the given pad.
754 //
c36ddf52 755
756 if (!HasOnlineFilterGain()) {
757 return 0x0;
758 }
ea3eaa08 759
760 const AliTRDCalOnlineGainTable *calOnline
761 = dynamic_cast<const AliTRDCalOnlineGainTable *>
762 (GetCachedCDBObject(kIDOnlineGainFactor));
763 if (!calOnline) {
764 return -1;
765 }
766
767 return calOnline->GetGainCorrectionFactor(det,row,col);
768
769}
770
56178ff4 771//_____________________________________________________________________________
772AliTRDCalROC *AliTRDcalibDB::GetGainFactorROC(Int_t det)
773{
774 //
775 // Returns the gain factor calibration object for a given ROC
56178ff4 776 //
777
778 const AliTRDCalPad *calPad = dynamic_cast<const AliTRDCalPad *>
779 (GetCachedCDBObject(kIDGainFactorPad));
780 if (!calPad) {
781 return 0;
782 }
783
784 AliTRDCalROC *roc = calPad->GetCalROC(det);
785 if (!roc) {
786 return 0;
787 }
788 else {
789 return roc;
790 }
791
792}
793
c36ddf52 794//_____________________________________________________________________________
795Float_t AliTRDcalibDB::GetGainFactor(Int_t det, Int_t col, Int_t row)
796{
797 //
798 // Returns the gain factor for the given pad.
799 //
800
801 const AliTRDCalPad *calPad = dynamic_cast<const AliTRDCalPad *>
802 (GetCachedCDBObject(kIDGainFactorPad));
803 if (!calPad) {
804 return -1;
805 }
806
807 AliTRDCalROC *roc = calPad->GetCalROC(det);
808 if (!roc) {
809 return -1;
810 }
811
812 const AliTRDCalDet *calChamber = dynamic_cast<const AliTRDCalDet *>
813 (GetCachedCDBObject(kIDGainFactorChamber));
814 if (!calChamber) {
815 return -1;
816 }
817
818 return calChamber->GetValue(det) * roc->GetValue(col,row);
819
820}
821
56178ff4 822//_____________________________________________________________________________
823const AliTRDCalDet *AliTRDcalibDB::GetGainFactorDet()
824{
825 //
826 // Returns the gain factor calibration object
827 // containing one number per detector
828 //
829
830 const AliTRDCalDet *calChamber = dynamic_cast<const AliTRDCalDet *>
831 (GetCachedCDBObject(kIDGainFactorChamber));
832 if (!calChamber) {
833 return 0;
834 }
835 else {
836 return calChamber;
837 }
838
839}
840
7754cd1f 841//_____________________________________________________________________________
842Float_t AliTRDcalibDB::GetGainFactorAverage(Int_t det)
843{
844 //
845 // Returns the average gain factor for the given detector
846 //
847
95867fd1 848 const AliTRDCalDet *calDet = dynamic_cast<const AliTRDCalDet *>
6d50f529 849 (GetCachedCDBObject(kIDGainFactorChamber));
850 if (!calDet) {
7754cd1f 851 return -1;
6d50f529 852 }
7754cd1f 853
854 return calDet->GetValue(det);
2745a409 855
acba9bad 856}
6a739e92 857
524fc8fa 858//_____________________________________________________________________________
859AliTRDCalROC *AliTRDcalibDB::GetPRFROC(Int_t det)
860{
861 //
862 // Returns the PRF calibration object for a given ROC
863 // containing one number per pad
864 //
865
866 const AliTRDCalPad *calPad = dynamic_cast<const AliTRDCalPad *>
867 (GetCachedCDBObject(kIDPRFWidth));
868 if (!calPad) {
869 return 0;
870 }
871
872 AliTRDCalROC *roc = calPad->GetCalROC(det);
873 if (!roc) {
874 return 0;
875 }
876 else {
877 return roc;
878 }
879
880}
881
6a739e92 882//_____________________________________________________________________________
883Float_t AliTRDcalibDB::GetPRFWidth(Int_t det, Int_t col, Int_t row)
884{
885 //
886 // Returns the PRF width for the given pad.
887 //
888
95867fd1 889 const AliTRDCalPad *calPad = dynamic_cast<const AliTRDCalPad *>
6d50f529 890 (GetCachedCDBObject(kIDPRFWidth));
891 if (!calPad) {
6a739e92 892 return -1;
6d50f529 893 }
6a739e92 894
95867fd1 895 AliTRDCalROC *roc = calPad->GetCalROC(det);
6d50f529 896 if (!roc) {
6a739e92 897 return -1;
6d50f529 898 }
6a739e92 899
95867fd1 900 return roc->GetValue(col,row);
2745a409 901
acba9bad 902}
3551db50 903
904//_____________________________________________________________________________
5b7ccf04 905Int_t AliTRDcalibDB::ExtractTimeBinsFromString(TString tbstr)
3551db50 906{
a835b5d7 907 // default value - has not been set
908 Int_t nUndef = -1;
c6f7c6cb 909
a835b5d7 910 // Check if there is any content in the string first
911 if (tbstr.Length() == 0) {
912 AliError("Parameter for number of timebins is empty!");
c6f7c6cb 913 return nUndef;
e232d349 914 }
c6f7c6cb 915
a835b5d7 916 // Check if we have the correct config parameter
917 TString tbident = "tb";
918 TString tbsubstr = tbstr(0,2);
919 if (!tbsubstr.EqualTo(tbident)) {
920 AliError(Form("Parameter for number of timebins is corrupted (%s)!", tbstr.Data()));
921 return nUndef;
922 }
c6f7c6cb 923
a835b5d7 924 tbstr.Remove(0,2);
925 // check if there is more than a number
926 if (!tbstr.IsDigit()) {
927 AliError(Form("Parameter for number of timebins is corrupted (%s)!", tbstr.Data()));
928 return nUndef;
e232d349 929 }
d6a1ec13 930
5b7ccf04 931 return tbstr.Atoi();
c6f7c6cb 932
5b7ccf04 933}
934
935//_____________________________________________________________________________
936Int_t AliTRDcalibDB::GetNumberOfTimeBinsDCS()
937{
938 //
939 // Returns number of time bins from the DCS
940 //
941
942 // Get the corresponding parameter
943 TString cfgstr = "", cfgname = "";
944 GetGlobalConfiguration(cfgname);
945 GetDCSConfigParOption(cfgname, kTimebin, 0, cfgstr);
946
947 return ExtractTimeBinsFromString(cfgstr);
ea3eaa08 948
e232d349 949}
950
951//_____________________________________________________________________________
f1dcad37 952void AliTRDcalibDB::GetFilterType(TString &filterType)
953{
954 //
955 // Returns the filter type
956 //
957
5b7ccf04 958 TString cfgname = "";
959 GetGlobalConfiguration(cfgname);
960 GetDCSConfigParOption(cfgname, kFltrSet, 0, filterType);
d6a1ec13 961
af086c5e 962}
963
964//_____________________________________________________________________________
ea3eaa08 965Int_t AliTRDcalibDB::GetOnlineGainTableID()
966{
967 //
968 // Get the gain table ID from the DCS
969 //
970
971 if (fOnlineGainTableID > 0) {
972 return fOnlineGainTableID;
973 }
974
975 const TObjArray *dcsArr = dynamic_cast<const TObjArray *>(GetCachedCDBObject(kIDDCS));
976 if (!dcsArr){
977 return -1;
978 }
979
980 Int_t esor = 0; // Take SOR
981 Int_t calver = 0; // Check CalDCS version
982 if (!strcmp(dcsArr->At(0)->ClassName(),"AliTRDCalDCS")) calver = 1;
983 if (!strcmp(dcsArr->At(0)->ClassName(),"AliTRDCalDCSv2")) calver = 2;
984
985 if (calver == 1) {
986
987 // No data for old DCS object available, anyway
988 return -1;
989
990 }
991 else if (calver == 2) {
992
993 // DCSv2 object
994 const AliTRDCalDCSv2 *calDCSv2 = dynamic_cast<const AliTRDCalDCSv2 *>(dcsArr->At(esor));
995 if(!calDCSv2){
996 return -1;
997 }
998
999 TString tableName = "";
1000 for (Int_t i = 0; i < 540; i++) {
1001 const AliTRDCalDCSFEEv2 *calDCSFEEv2 = calDCSv2->GetCalDCSFEEObj(0);
1002 tableName = calDCSFEEv2->GetGainTableName();
1003 if (tableName.Length() > 0) {
1004 break;
1005 }
1006 }
412d07b9 1007 if (tableName.CompareTo("Krypton_2011-01") == 0) {
ea3eaa08 1008 fOnlineGainTableID = 1;
1009 return fOnlineGainTableID;
1010 }
412d07b9 1011 if (tableName.CompareTo("Gaintbl_Uniform_FGAN0_2011-01") == 0) {
1012 fOnlineGainTableID = 2;
1013 return fOnlineGainTableID;
1014 }
1015 if (tableName.CompareTo("Gaintbl_Uniform_FGAN8_2011-01") == 0) {
1016 fOnlineGainTableID = 3;
1017 return fOnlineGainTableID;
1018 }
3abf1c06 1019 if (tableName.CompareTo("Krypton_2011-02") == 0) {
1020 fOnlineGainTableID = 4;
1021 return fOnlineGainTableID;
1022 }
4a05be5f 1023 if (tableName.CompareTo("Krypton_2011-03") == 0) {
1024 fOnlineGainTableID = 5;
1025 return fOnlineGainTableID;
1026 }
1027 if (tableName.CompareTo("Gaintbl_Uniform_FGAN0_2012-01") == 0) {
1028 fOnlineGainTableID = 6;
1029 return fOnlineGainTableID;
1030 }
1031 if (tableName.CompareTo("Gaintbl_Uniform_FGAN8_2012-01") == 0) {
1032 fOnlineGainTableID = 7;
1033 return fOnlineGainTableID;
1034 }
ea3eaa08 1035
1036 }
1037 else {
1038
1039 AliError("NO DCS/DCSv2 OCDB entry found!");
1040 return -1;
1041
1042 }
1043
45b38fb0 1044 return -1;
1045
ea3eaa08 1046}
1047
1048//_____________________________________________________________________________
1049void AliTRDcalibDB::GetGlobalConfiguration(TString &config)
1050{
af086c5e 1051 //
1052 // Get Configuration from the DCS
1053 //
d6a1ec13 1054
af086c5e 1055 const TObjArray *dcsArr = dynamic_cast<const TObjArray *>(GetCachedCDBObject(kIDDCS));
1056 if(!dcsArr){
a835b5d7 1057 AliError("No DCS CDB Object available!");
af086c5e 1058 config = "";
1059 return;
1060 }
d6a1ec13 1061
a835b5d7 1062 Int_t idSOR = 0, idEOR=1; // The index of SOR and EOR
1063 Bool_t hasSOR = (dcsArr->At(idSOR));
1064 Bool_t hasEOR = (dcsArr->At(idEOR));
1065 TString cfgSOR = "", cfgEOR = ""; // The configuration at SOR/EOR
d6a1ec13 1066
a835b5d7 1067 // The SOR object is mandatory
1068 if (!hasSOR) {
1069 AliError("NO SOR object found in CDB file!");
1070 config = "";
1071 return;
1072 }
1073 if (!hasEOR) AliWarning("NO EOR object found in CDB file!");
ea3eaa08 1074
a835b5d7 1075 // Check CalDCS version
1076 Int_t calver = 0;
1077 if (!strcmp(dcsArr->At(idSOR)->ClassName(),"AliTRDCalDCS")) calver = 1;
1078 else if (!strcmp(dcsArr->At(idSOR)->ClassName(),"AliTRDCalDCSv2")) calver = 2;
ea3eaa08 1079
a835b5d7 1080 // Get the configuration strings
1081 if (calver == 1) {
1082 // DCS object
1083 const AliTRDCalDCS *calSOR = dynamic_cast<const AliTRDCalDCS *>(dcsArr->At(idSOR));
1084 cfgSOR = calSOR->GetGlobalConfigName();
1085 if (hasEOR) {
1086 const AliTRDCalDCS *calEOR = dynamic_cast<const AliTRDCalDCS *>(dcsArr->At(idEOR));
1087 cfgEOR = calEOR->GetGlobalConfigName();
1088 }
ea3eaa08 1089 }
1090 else if (calver == 2) {
d6a1ec13 1091 // DCSv2 object
a835b5d7 1092 const AliTRDCalDCSv2 *calv2SOR = dynamic_cast<const AliTRDCalDCSv2 *>(dcsArr->At(idSOR));
1093 cfgSOR = calv2SOR->GetGlobalConfigName();
1094 if (hasEOR) {
1095 const AliTRDCalDCSv2 *calv2EOR = dynamic_cast<const AliTRDCalDCSv2 *>(dcsArr->At(idEOR));
1096 cfgEOR = calv2EOR->GetGlobalConfigName();
1097 }
ea3eaa08 1098 }
1099 else {
ea3eaa08 1100 AliError("NO DCS/DCSv2 OCDB entry found!");
a835b5d7 1101 config = "";
1102 return;
1103 }
ea3eaa08 1104
a835b5d7 1105 // If there is no EOR entry, return the SOR value
1106 if (!hasEOR || cfgEOR.Length()==0) {
1107 config = cfgSOR;
1108 return;
ea3eaa08 1109 }
d6a1ec13 1110
a835b5d7 1111 // Check if the configuration is the same for both
1112 if (cfgSOR.EqualTo(cfgEOR)) {
1113 config = cfgSOR;
1114 return;
1115 }
1116
1117 // When both SOR and EOR have an entry but are different, the config is not defined
1118 AliError("Inconsistent configuration at start and end of run found!");
1119 config = "";
1120 return;
1121
af086c5e 1122}
f1dcad37 1123
f8059b39 1124//_____________________________________________________________________________
1125void AliTRDcalibDB::GetGlobalConfigurationVersion(TString &version)
1126{
1127 //
1128 // Get Version of Configuration from the DCS
1129 //
1130
1131 const TObjArray *dcsArr = dynamic_cast<const TObjArray *>(GetCachedCDBObject(kIDDCS));
1132 if(!dcsArr){
1133 version = "";
1134 return;
1135 }
1136
1137 Int_t esor = 0; // Take SOR
1138 Int_t calver = 0; // Check CalDCS version
1139 if (!strcmp(dcsArr->At(0)->ClassName(),"AliTRDCalDCS")) calver = 1;
1140 if (!strcmp(dcsArr->At(0)->ClassName(),"AliTRDCalDCSv2")) calver = 2;
1141
1142 if (calver == 1) {
1143
1144 // DCS object
1145 const AliTRDCalDCS *calDCS = dynamic_cast<const AliTRDCalDCS *>(dcsArr->At(esor));
1146 if(!calDCS){
1147 version = "";
1148 return;
1149 }
1150 version = calDCS->GetGlobalConfigVersion();
1151
1152 }
1153 else if (calver == 2) {
1154
1155 // DCSv2 object
1156 const AliTRDCalDCSv2 *calDCSv2 = dynamic_cast<const AliTRDCalDCSv2 *>(dcsArr->At(esor));
1157 if(!calDCSv2){
1158 version = "";
1159 return;
1160 }
1161 version = calDCSv2->GetGlobalConfigVersion();
1162
1163 }
1164 else {
1165
1166 AliError("NO DCS/DCSv2 OCDB entry found!");
1167
1168 }
1169
1170}
1171
af086c5e 1172//_____________________________________________________________________________
5b7ccf04 1173Int_t AliTRDcalibDB::GetNumberOfParsDCS(TString cname)
1174{
1175 // Get the number of configuration parameters from the DCS config
1176
1177 TString cdelim = "_";
1178 TObjArray *carr = cname.Tokenize(cdelim);
1179 return carr->GetEntries() - 1; // -1 for the "cf"
1180
1181}
1182
1183//_____________________________________________________________________________
1184Int_t AliTRDcalibDB::GetNumberOfOptsDCS(TString cname, Int_t cfgType)
1185{
1186 // Get the number of options of a given configuration parameter from DCS
1187
1188 TString cdelim = "_";
1189 TString odelim = "-";
1190
1191 TObjArray *carr = cname.Tokenize(cdelim);
1192 Int_t nconfig = carr->GetEntries();
1193
1194 // protect
1195 if ((nconfig == 0) || ((nconfig-1) < cfgType)) {
1196 AliError("Not enough parameters in DCS configuration name!");
1197 return 0;
1198 }
1199
1200 TString fullcfg = ((TObjString*)carr->At(cfgType))->GetString();
1201 TObjArray *oarr = fullcfg.Tokenize(odelim);
1202 return oarr->GetEntries() -1; // -1 for the parameter name
1203
1204}
1205
1206//_____________________________________________________________________________
1207void AliTRDcalibDB::GetDCSConfigParOption(TString cname, Int_t cfgType, Int_t option, TString &cfgo)
af086c5e 1208{
1209 //
fc358d0f 1210 // Get a configuration (see enum in header file) or the options of a configuration
1211 // option == 0 returns the configuration itself
1212 // option > 0 returns the optional parameter Nr. (option) of the configuration (cfgType)
af086c5e 1213 //
ea3eaa08 1214
fc358d0f 1215 // define the delimiters
1216 TString cdelim = "_";
1217 TString odelim = "-";
ea3eaa08 1218
fc358d0f 1219 TObjArray *carr = cname.Tokenize(cdelim);
1220 Int_t nconfig = carr->GetEntries();
1221
1222 // protect
1223 if (nconfig == 0) {
5b7ccf04 1224 AliError("DCS configuration name empty!");
fc358d0f 1225 cfgo = "";
1226 return;
1227 } else if ((nconfig-1) < cfgType) {
5b7ccf04 1228 AliError("Not enough parameters in DCS configuration name!");
fc358d0f 1229 cfgo = "";
1230 return;
1231 }
1232
1233 TString fullcfg = ((TObjString*)carr->At(cfgType))->GetString();
5b7ccf04 1234 TObjArray *oarr = fullcfg.Tokenize(odelim);
1235 Int_t noptions = oarr->GetEntries();
fc358d0f 1236
5b7ccf04 1237 // protect
1238 if ((noptions-1) < option) {
1239 AliError("Not enough options in DCS configuration name!");
1240 cfgo = "";
fc358d0f 1241 return;
fc358d0f 1242 }
fc358d0f 1243
5b7ccf04 1244 cfgo = ((TObjString*)oarr->At(option))->GetString();
1245 return;
fc358d0f 1246
1247}
1248
1249//_____________________________________________________________________________
1250Bool_t AliTRDcalibDB::HasOnlineFilterPedestal()
1251{
1252 //
1253 // Checks whether pedestal filter was applied online
1254 //
1255
1256 TString filterconfig;
1257 GetFilterType(filterconfig);
ea3eaa08 1258
af086c5e 1259 return filterconfig.Contains("p");
ea3eaa08 1260
af086c5e 1261}
1262
1263//_____________________________________________________________________________
ea3eaa08 1264Bool_t AliTRDcalibDB::HasOnlineFilterGain()
1265{
af086c5e 1266 //
1267 // Checks whether online gain filter was applied
1268 //
ea3eaa08 1269
fc358d0f 1270 TString filterconfig;
1271 GetFilterType(filterconfig);
ea3eaa08 1272
af086c5e 1273 return filterconfig.Contains("g");
ea3eaa08 1274
af086c5e 1275}
1276
1277//_____________________________________________________________________________
ea3eaa08 1278Bool_t AliTRDcalibDB::HasOnlineTailCancellation()
1279{
af086c5e 1280 //
1281 // Checks whether online tail cancellation was applied
1282 //
ea3eaa08 1283
fc358d0f 1284 TString filterconfig;
1285 GetFilterType(filterconfig);
ea3eaa08 1286
af086c5e 1287 return filterconfig.Contains("t");
ea3eaa08 1288
e232d349 1289}
1290
7754cd1f 1291//_____________________________________________________________________________
1292Char_t AliTRDcalibDB::GetPadStatus(Int_t det, Int_t col, Int_t row)
1293{
1294 //
1295 // Returns the status of the given pad
1296 //
1297
aa617684 1298 const AliTRDCalPadStatus *cal = dynamic_cast<const AliTRDCalPadStatus *>
1299 (GetCachedCDBObject(kIDPadStatus));
6d50f529 1300 if (!cal) {
7754cd1f 1301 return -1;
6d50f529 1302 }
7754cd1f 1303
95867fd1 1304 const AliTRDCalSingleChamberStatus *roc = cal->GetCalROC(det);
6d50f529 1305 if (!roc) {
7754cd1f 1306 return -1;
6d50f529 1307 }
7754cd1f 1308
95867fd1 1309 return roc->GetStatus(col,row);
2745a409 1310
7754cd1f 1311}
1312
0e09df31 1313//_____________________________________________________________________________
1314AliTRDCalSingleChamberStatus* AliTRDcalibDB::GetPadStatusROC(Int_t det)
1315{
1316 //
1317 // Returns the pad status calibration object for a given ROC
1318 //
1319
1320 const AliTRDCalPadStatus *cal = dynamic_cast<const AliTRDCalPadStatus *>
1321 (GetCachedCDBObject(kIDPadStatus));
1322 if (!cal) {
1323 return 0;
1324 }
1325
1326 AliTRDCalSingleChamberStatus *roc = cal->GetCalROC(det);
1327 if (!roc) {
1328 return 0;
1329 }
1330 else {
1331 return roc;
1332 }
1333
1334}
1335
7754cd1f 1336//_____________________________________________________________________________
1337Char_t AliTRDcalibDB::GetChamberStatus(Int_t det)
1338{
1339 //
1340 // Returns the status of the given chamber
1341 //
1342
95867fd1 1343 const AliTRDCalChamberStatus *cal = dynamic_cast<const AliTRDCalChamberStatus *>
6d50f529 1344 (GetCachedCDBObject(kIDChamberStatus));
1345 if (!cal) {
7754cd1f 1346 return -1;
6d50f529 1347 }
7754cd1f 1348
1349 return cal->GetStatus(det);
2745a409 1350
7754cd1f 1351}
1352
a7ac01d2 1353//_____________________________________________________________________________
1354AliTRDrecoParam* AliTRDcalibDB::GetRecoParam(Int_t */*eventtype*/)
1355{
be28462a 1356 //
1357 // Returns the TRD reconstruction parameters from the OCDB
1358 //
1359
a7ac01d2 1360 const TClonesArray *recos = dynamic_cast<const TClonesArray*>(GetCachedCDBObject(kIDRecoParam));
be28462a 1361 if (!recos) return 0x0;
a7ac01d2 1362
1363 // calculate entry based on event type info
1364 Int_t n = 0; //f(eventtype[0], eventtype[1], ....)
be28462a 1365
ea3eaa08 1366 return (AliTRDrecoParam *) recos->UncheckedAt(n);
a7ac01d2 1367
be28462a 1368}
a7ac01d2 1369
7754cd1f 1370//_____________________________________________________________________________
1371Bool_t AliTRDcalibDB::IsPadMasked(Int_t det, Int_t col, Int_t row)
1372{
1373 //
1374 // Returns status, see name of functions for details ;-)
1375 //
1376
95867fd1 1377 const AliTRDCalPadStatus *cal = dynamic_cast<const AliTRDCalPadStatus *>
1378 (GetCachedCDBObject(kIDPadStatus));
6d50f529 1379 if (!cal) {
7754cd1f 1380 return -1;
6d50f529 1381 }
7754cd1f 1382
95867fd1 1383 return cal->IsMasked(det,col,row);
2745a409 1384
7754cd1f 1385}
1386
1387//_____________________________________________________________________________
1388Bool_t AliTRDcalibDB::IsPadBridgedLeft(Int_t det, Int_t col, Int_t row)
1389{
1390 //
1391 // Returns status, see name of functions for details ;-)
1392 //
1393
95867fd1 1394 const AliTRDCalPadStatus *cal = dynamic_cast<const AliTRDCalPadStatus *>
1395 (GetCachedCDBObject(kIDPadStatus));
6d50f529 1396 if (!cal) {
7754cd1f 1397 return -1;
6d50f529 1398 }
7754cd1f 1399
95867fd1 1400 return cal->IsBridgedLeft(det,col,row);
2745a409 1401
7754cd1f 1402}
1403
1404//_____________________________________________________________________________
1405Bool_t AliTRDcalibDB::IsPadBridgedRight(Int_t det, Int_t col, Int_t row)
1406{
1407 //
1408 // Returns status, see name of functions for details ;-)
1409 //
1410
95867fd1 1411 const AliTRDCalPadStatus * cal = dynamic_cast<const AliTRDCalPadStatus *>
1412 (GetCachedCDBObject(kIDPadStatus));
6d50f529 1413 if (!cal) {
7754cd1f 1414 return -1;
6d50f529 1415 }
7754cd1f 1416
95867fd1 1417 return cal->IsBridgedRight(det,col,row);
2745a409 1418
7754cd1f 1419}
1420
fa7427d0 1421//_____________________________________________________________________________
1422Bool_t AliTRDcalibDB::IsPadNotConnected(Int_t det, Int_t col, Int_t row)
1423{
1424 //
1425 // Returns status, see name of functions for details ;-)
1426 //
f1dcad37 1427
fa7427d0 1428 const AliTRDCalPadStatus * cal = dynamic_cast<const AliTRDCalPadStatus *>
1429 (GetCachedCDBObject(kIDPadStatus));
1430 if (!cal) {
1431 return -1;
1432 }
1433
1434 return cal->IsNotConnected(det,col,row);
1435
1436}
1437
7754cd1f 1438//_____________________________________________________________________________
eda91732 1439Bool_t AliTRDcalibDB::IsChamberGood(Int_t det)
1440{
1441 //
1442 // Returns status, see name of functions for details ;-)
1443 //
1444
1445 const AliTRDCalChamberStatus * cal = dynamic_cast<const AliTRDCalChamberStatus *>
1446 (GetCachedCDBObject(kIDChamberStatus));
1447 if (!cal) {
1448 return -1;
1449 }
1450
1451 return cal->IsGood(det);
1452
1453}
1454
1455//_____________________________________________________________________________
1456Bool_t AliTRDcalibDB::IsChamberNoData(Int_t det)
7754cd1f 1457{
1458 //
1459 // Returns status, see name of functions for details ;-)
1460 //
1461
95867fd1 1462 const AliTRDCalChamberStatus * cal = dynamic_cast<const AliTRDCalChamberStatus *>
1463 (GetCachedCDBObject(kIDChamberStatus));
6d50f529 1464 if (!cal) {
7754cd1f 1465 return -1;
6d50f529 1466 }
7754cd1f 1467
eda91732 1468 return cal->IsNoData(det);
2745a409 1469
7754cd1f 1470}
1471
1472//_____________________________________________________________________________
eda91732 1473Bool_t AliTRDcalibDB::IsHalfChamberNoData(Int_t det, Int_t side)
7754cd1f 1474{
1475 //
1476 // Returns status, see name of functions for details ;-)
1477 //
1478
95867fd1 1479 const AliTRDCalChamberStatus * cal = dynamic_cast<const AliTRDCalChamberStatus *>
1480 (GetCachedCDBObject(kIDChamberStatus));
6d50f529 1481 if (!cal) {
7754cd1f 1482 return -1;
6d50f529 1483 }
7754cd1f 1484
eda91732 1485 return side > 0 ? cal->IsNoDataSideB(det) : cal->IsNoDataSideA(det);
2745a409 1486
7754cd1f 1487}
ea3eaa08 1488
7a6352a6 1489//_____________________________________________________________________________
eda91732 1490Bool_t AliTRDcalibDB::IsChamberBadCalibrated(Int_t det)
ea3eaa08 1491{
7a6352a6 1492 //
1493 // Returns status, see name of functions for details ;-)
1494 //
7754cd1f 1495
7a6352a6 1496 const AliTRDCalChamberStatus * cal = dynamic_cast<const AliTRDCalChamberStatus *>
1497 (GetCachedCDBObject(kIDChamberStatus));
1498 if (!cal) {
1499 return -1;
1500 }
1501
eda91732 1502 return cal->IsBadCalibrated(det);
7a6352a6 1503
1504}
ea3eaa08 1505
cc7cef99 1506//_____________________________________________________________________________
0d83b3a5 1507const AliTRDCalPID *AliTRDcalibDB::GetPIDObject(AliTRDpidUtil::ETRDPIDMethod method)
cc7cef99 1508{
1509 //
1510 // Returns the object storing the distributions for PID with likelihood
1511 //
9a96f175 1512
1513 switch(method) {
0d83b3a5 1514 case AliTRDpidUtil::kLQ:
4ba1d6ae 1515 return dynamic_cast<const AliTRDCalPID *>(GetCachedCDBObject(kIDPIDLQ));
0d83b3a5 1516 case AliTRDpidUtil::kNN:
4ba1d6ae 1517 return dynamic_cast<const AliTRDCalPID *>(GetCachedCDBObject(kIDPIDNN));
543691ea 1518 case AliTRDpidUtil::kESD:
1519 return 0x0; // To avoid compiler warnings
9a96f175 1520 }
1521
10f75631 1522 return 0x0;
2745a409 1523
cc7cef99 1524}
1525
9dcc64cc 1526//_____________________________________________________________________________
ea3eaa08 1527AliTRDPIDResponse *AliTRDcalibDB::GetPIDResponse(AliTRDPIDResponse::ETRDPIDMethod method)
1528{
1529 //
1530 // Returns the PID response object for 1D-LQ
1531 //
1532
1533 if (!fPIDResponse) {
1534
9dcc64cc 1535 fPIDResponse = new AliTRDPIDResponse;
ea3eaa08 1536
9dcc64cc 1537 // Load Reference Histos from OCDB
1538 fPIDResponse->SetPIDmethod(method);
51a0ce25 1539 const TObjArray *references = dynamic_cast<const TObjArray *>(GetCachedCDBObject(kIDPIDLQ1D));
ea3eaa08 1540
51a0ce25 1541 TIter refs(references);
1542 TObject *obj = NULL;
1543 AliTRDPIDReference *ref = NULL;
1544 Bool_t hasReference = kFALSE;
ea3eaa08 1545 while ((obj = refs())){
1546 if ((ref = dynamic_cast<AliTRDPIDReference *>(obj))){
db0e2c5f 1547 //fPIDResponse->Load(ref);
ea3eaa08 1548 hasReference = kTRUE;
1549 break;
1550 }
51a0ce25 1551 }
ea3eaa08 1552
1553 if (!hasReference) {
1554 AliError("Reference histograms not found in the OCDB");
1555 }
1556
9dcc64cc 1557 }
ea3eaa08 1558
9dcc64cc 1559 return fPIDResponse;
ea3eaa08 1560
9dcc64cc 1561}
1562
1563//_____________________________________________________________________________
1564const AliTRDCalTrkAttach* AliTRDcalibDB::GetAttachObject()
1565{
1566 //
1567 // Returns the object storing likelihood distributions for cluster to track attachment
1568 //
ea3eaa08 1569
9dcc64cc 1570 return dynamic_cast<const AliTRDCalTrkAttach*>(GetCachedCDBObject(kIDAttach));
9dcc64cc 1571
ea3eaa08 1572}
9dcc64cc 1573
7754cd1f 1574//_____________________________________________________________________________
d4c6453d 1575const AliTRDCalMonitoring *AliTRDcalibDB::GetMonitoringObject()
7754cd1f 1576{
1577 //
1578 // Returns the object storing the monitoring data
1579 //
1580
d4c6453d 1581 return dynamic_cast<const AliTRDCalMonitoring *>
1582 (GetCachedCDBObject(kIDMonitoringData));
1b95a37b 1583
7754cd1f 1584}
1585
6a739e92 1586//_____________________________________________________________________________
1587void AliTRDcalibDB::SamplePRF()
1588{
1589 //
2745a409 1590 // Samples the pad response function (should maybe go somewhere else ...)
6a739e92 1591 //
1592
1593 const Int_t kPRFbin = 61;
1594
053767a4 1595 Float_t prf[kNlayer][kPRFbin] = {
6d50f529 1596 {2.9037e-02, 3.3608e-02, 3.9020e-02, 4.5292e-02,
6a739e92 1597 5.2694e-02, 6.1362e-02, 7.1461e-02, 8.3362e-02,
1598 9.7063e-02, 1.1307e-01, 1.3140e-01, 1.5235e-01,
1599 1.7623e-01, 2.0290e-01, 2.3294e-01, 2.6586e-01,
1600 3.0177e-01, 3.4028e-01, 3.8077e-01, 4.2267e-01,
1601 4.6493e-01, 5.0657e-01, 5.4655e-01, 5.8397e-01,
1602 6.1767e-01, 6.4744e-01, 6.7212e-01, 6.9188e-01,
1603 7.0627e-01, 7.1499e-01, 7.1851e-01, 7.1499e-01,
1604 7.0627e-01, 6.9188e-01, 6.7212e-01, 6.4744e-01,
1605 6.1767e-01, 5.8397e-01, 5.4655e-01, 5.0657e-01,
1606 4.6493e-01, 4.2267e-01, 3.8077e-01, 3.4028e-01,
1607 3.0177e-01, 2.6586e-01, 2.3294e-01, 2.0290e-01,
1608 1.7623e-01, 1.5235e-01, 1.3140e-01, 1.1307e-01,
1609 9.7063e-02, 8.3362e-02, 7.1461e-02, 6.1362e-02,
1610 5.2694e-02, 4.5292e-02, 3.9020e-02, 3.3608e-02,
1611 2.9037e-02},
1612 {2.5478e-02, 2.9695e-02, 3.4655e-02, 4.0454e-02,
1613 4.7342e-02, 5.5487e-02, 6.5038e-02, 7.6378e-02,
1614 8.9696e-02, 1.0516e-01, 1.2327e-01, 1.4415e-01,
1615 1.6794e-01, 1.9516e-01, 2.2573e-01, 2.5959e-01,
1616 2.9694e-01, 3.3719e-01, 3.7978e-01, 4.2407e-01,
1617 4.6889e-01, 5.1322e-01, 5.5569e-01, 5.9535e-01,
1618 6.3141e-01, 6.6259e-01, 6.8882e-01, 7.0983e-01,
1619 7.2471e-01, 7.3398e-01, 7.3761e-01, 7.3398e-01,
1620 7.2471e-01, 7.0983e-01, 6.8882e-01, 6.6259e-01,
1621 6.3141e-01, 5.9535e-01, 5.5569e-01, 5.1322e-01,
1622 4.6889e-01, 4.2407e-01, 3.7978e-01, 3.3719e-01,
1623 2.9694e-01, 2.5959e-01, 2.2573e-01, 1.9516e-01,
1624 1.6794e-01, 1.4415e-01, 1.2327e-01, 1.0516e-01,
1625 8.9696e-02, 7.6378e-02, 6.5038e-02, 5.5487e-02,
1626 4.7342e-02, 4.0454e-02, 3.4655e-02, 2.9695e-02,
1627 2.5478e-02},
1628 {2.2363e-02, 2.6233e-02, 3.0782e-02, 3.6140e-02,
1629 4.2535e-02, 5.0157e-02, 5.9197e-02, 6.9900e-02,
1630 8.2707e-02, 9.7811e-02, 1.1548e-01, 1.3601e-01,
1631 1.5998e-01, 1.8739e-01, 2.1840e-01, 2.5318e-01,
1632 2.9182e-01, 3.3373e-01, 3.7837e-01, 4.2498e-01,
1633 4.7235e-01, 5.1918e-01, 5.6426e-01, 6.0621e-01,
1634 6.4399e-01, 6.7700e-01, 7.0472e-01, 7.2637e-01,
1635 7.4206e-01, 7.5179e-01, 7.5551e-01, 7.5179e-01,
1636 7.4206e-01, 7.2637e-01, 7.0472e-01, 6.7700e-01,
1637 6.4399e-01, 6.0621e-01, 5.6426e-01, 5.1918e-01,
1638 4.7235e-01, 4.2498e-01, 3.7837e-01, 3.3373e-01,
1639 2.9182e-01, 2.5318e-01, 2.1840e-01, 1.8739e-01,
1640 1.5998e-01, 1.3601e-01, 1.1548e-01, 9.7811e-02,
1641 8.2707e-02, 6.9900e-02, 5.9197e-02, 5.0157e-02,
1642 4.2535e-02, 3.6140e-02, 3.0782e-02, 2.6233e-02,
1643 2.2363e-02},
1644 {1.9635e-02, 2.3167e-02, 2.7343e-02, 3.2293e-02,
1645 3.8224e-02, 4.5335e-02, 5.3849e-02, 6.4039e-02,
1646 7.6210e-02, 9.0739e-02, 1.0805e-01, 1.2841e-01,
1647 1.5216e-01, 1.7960e-01, 2.1099e-01, 2.4671e-01,
1648 2.8647e-01, 3.2996e-01, 3.7660e-01, 4.2547e-01,
1649 4.7536e-01, 5.2473e-01, 5.7215e-01, 6.1632e-01,
1650 6.5616e-01, 6.9075e-01, 7.1939e-01, 7.4199e-01,
1651 7.5838e-01, 7.6848e-01, 7.7227e-01, 7.6848e-01,
1652 7.5838e-01, 7.4199e-01, 7.1939e-01, 6.9075e-01,
1653 6.5616e-01, 6.1632e-01, 5.7215e-01, 5.2473e-01,
1654 4.7536e-01, 4.2547e-01, 3.7660e-01, 3.2996e-01,
1655 2.8647e-01, 2.4671e-01, 2.1099e-01, 1.7960e-01,
1656 1.5216e-01, 1.2841e-01, 1.0805e-01, 9.0739e-02,
1657 7.6210e-02, 6.4039e-02, 5.3849e-02, 4.5335e-02,
1658 3.8224e-02, 3.2293e-02, 2.7343e-02, 2.3167e-02,
1659 1.9635e-02},
1660 {1.7224e-02, 2.0450e-02, 2.4286e-02, 2.8860e-02,
1661 3.4357e-02, 4.0979e-02, 4.8966e-02, 5.8612e-02,
1662 7.0253e-02, 8.4257e-02, 1.0102e-01, 1.2094e-01,
1663 1.4442e-01, 1.7196e-01, 2.0381e-01, 2.4013e-01,
1664 2.8093e-01, 3.2594e-01, 3.7450e-01, 4.2563e-01,
1665 4.7796e-01, 5.2991e-01, 5.7974e-01, 6.2599e-01,
1666 6.6750e-01, 7.0344e-01, 7.3329e-01, 7.5676e-01,
1667 7.7371e-01, 7.8410e-01, 7.8793e-01, 7.8410e-01,
1668 7.7371e-01, 7.5676e-01, 7.3329e-01, 7.0344e-01,
1669 6.6750e-01, 6.2599e-01, 5.7974e-01, 5.2991e-01,
1670 4.7796e-01, 4.2563e-01, 3.7450e-01, 3.2594e-01,
1671 2.8093e-01, 2.4013e-01, 2.0381e-01, 1.7196e-01,
1672 1.4442e-01, 1.2094e-01, 1.0102e-01, 8.4257e-02,
1673 7.0253e-02, 5.8612e-02, 4.8966e-02, 4.0979e-02,
1674 3.4357e-02, 2.8860e-02, 2.4286e-02, 2.0450e-02,
1675 1.7224e-02},
1676 {1.5096e-02, 1.8041e-02, 2.1566e-02, 2.5793e-02,
1677 3.0886e-02, 3.7044e-02, 4.4515e-02, 5.3604e-02,
1678 6.4668e-02, 7.8109e-02, 9.4364e-02, 1.1389e-01,
1679 1.3716e-01, 1.6461e-01, 1.9663e-01, 2.3350e-01,
1680 2.7527e-01, 3.2170e-01, 3.7214e-01, 4.2549e-01,
1681 4.8024e-01, 5.3460e-01, 5.8677e-01, 6.3512e-01,
1682 6.7838e-01, 7.1569e-01, 7.4655e-01, 7.7071e-01,
1683 7.8810e-01, 7.9871e-01, 8.0255e-01, 7.9871e-01,
1684 7.8810e-01, 7.7071e-01, 7.4655e-01, 7.1569e-01,
1685 6.7838e-01, 6.3512e-01, 5.8677e-01, 5.3460e-01,
1686 4.8024e-01, 4.2549e-01, 3.7214e-01, 3.2170e-01,
1687 2.7527e-01, 2.3350e-01, 1.9663e-01, 1.6461e-01,
1688 1.3716e-01, 1.1389e-01, 9.4364e-02, 7.8109e-02,
1689 6.4668e-02, 5.3604e-02, 4.4515e-02, 3.7044e-02,
1690 3.0886e-02, 2.5793e-02, 2.1566e-02, 1.8041e-02,
1691 1.5096e-02}};
1692
1693 // More sampling precision with linear interpolation
6d50f529 1694 fPRFlo = -1.5;
1695 fPRFhi = 1.5;
6a739e92 1696 Float_t pad[kPRFbin];
1697 Int_t sPRFbin = kPRFbin;
6d50f529 1698 Float_t sPRFwid = (fPRFhi - fPRFlo) / ((Float_t) sPRFbin);
6a739e92 1699 for (Int_t iPad = 0; iPad < sPRFbin; iPad++) {
6d50f529 1700 pad[iPad] = ((Float_t) iPad + 0.5) * sPRFwid + fPRFlo;
6a739e92 1701 }
6d50f529 1702 fPRFbin = 500;
1703 fPRFwid = (fPRFhi - fPRFlo) / ((Float_t) fPRFbin);
1704 fPRFpad = ((Int_t) (1.0 / fPRFwid));
6a739e92 1705
6d50f529 1706 if (fPRFsmp) delete [] fPRFsmp;
053767a4 1707 fPRFsmp = new Float_t[kNlayer*fPRFbin];
6a739e92 1708
1709 Int_t ipos1;
1710 Int_t ipos2;
1711 Float_t diff;
1712
053767a4 1713 for (Int_t iLayer = 0; iLayer < kNlayer; iLayer++) {
6a739e92 1714
6d50f529 1715 for (Int_t iBin = 0; iBin < fPRFbin; iBin++) {
6a739e92 1716
6d50f529 1717 Float_t bin = (((Float_t) iBin) + 0.5) * fPRFwid + fPRFlo;
6a739e92 1718 ipos1 = ipos2 = 0;
1719 diff = 0;
1720 do {
1721 diff = bin - pad[ipos2++];
1722 } while ((diff > 0) && (ipos2 < kPRFbin));
1723 if (ipos2 == kPRFbin) {
053767a4 1724 fPRFsmp[iLayer*fPRFbin+iBin] = prf[iLayer][ipos2-1];
6a739e92 1725 }
1726 else if (ipos2 == 1) {
053767a4 1727 fPRFsmp[iLayer*fPRFbin+iBin] = prf[iLayer][ipos2-1];
6a739e92 1728 }
1729 else {
1730 ipos2--;
1731 if (ipos2 >= kPRFbin) ipos2 = kPRFbin - 1;
1732 ipos1 = ipos2 - 1;
053767a4 1733 fPRFsmp[iLayer*fPRFbin+iBin] = prf[iLayer][ipos2]
1734 + diff * (prf[iLayer][ipos2] - prf[iLayer][ipos1])
1735 / sPRFwid;
6a739e92 1736 }
1737
1738 }
1739 }
1740
1741}
1742
1743//_____________________________________________________________________________
1744Int_t AliTRDcalibDB::PadResponse(Double_t signal, Double_t dist
eb52b657 1745 , Int_t layer, Double_t *pad) const
6a739e92 1746{
1747 //
1748 // Applies the pad response
56178ff4 1749 // So far this is the fixed parametrization and should be replaced by
1750 // something dependent on calibration values
6a739e92 1751 //
1752
eb52b657 1753 Int_t iBin = ((Int_t) ((-dist - fPRFlo) / fPRFwid));
053767a4 1754 Int_t iOff = layer * fPRFbin;
6a739e92 1755
6d50f529 1756 Int_t iBin0 = iBin - fPRFpad + iOff;
6a739e92 1757 Int_t iBin1 = iBin + iOff;
6d50f529 1758 Int_t iBin2 = iBin + fPRFpad + iOff;
6a739e92 1759
1760 pad[0] = 0.0;
1761 pad[1] = 0.0;
1762 pad[2] = 0.0;
053767a4 1763 if ((iBin1 >= 0) && (iBin1 < (fPRFbin*kNlayer))) {
6a739e92 1764
1765 if (iBin0 >= 0) {
6d50f529 1766 pad[0] = signal * fPRFsmp[iBin0];
6a739e92 1767 }
6d50f529 1768 pad[1] = signal * fPRFsmp[iBin1];
053767a4 1769 if (iBin2 < (fPRFbin*kNlayer)) {
6d50f529 1770 pad[2] = signal * fPRFsmp[iBin2];
6a739e92 1771 }
1772
1773 return 1;
1774
1775 }
1776 else {
1777
1778 return 0;
1779
1780 }
ab0a4106 1781
3551db50 1782}
7a6352a6 1783
1784
a9e22145 1785AliTRDtrapConfig* AliTRDcalibDB::GetTrapConfig()
1786{
1787 // return an existing TRAPconfig or load it from the OCDB
1788 // in case of failure, a default TRAPconfig is created
1789
1790 if (fTrapConfig)
1791 return fTrapConfig;
1792 else {
1b1afdd3 1793 if ((fTrapConfigName.Length() <= 0) || (fTrapConfigVersion.Length() <= 0)) {
1794 // query the configuration to be used
1795 TString configName;
1796 this->GetGlobalConfiguration(configName);
1797 TString configVersion;
1798 this->GetGlobalConfigurationVersion(configVersion);
1799 }
a9e22145 1800
1b1afdd3 1801 // try to load the requested configuration
1802 this->LoadTrapConfig(fTrapConfigName, fTrapConfigVersion);
a9e22145 1803
1804 // if we still don't have a valid TRAPconfig, create a default one
1805 if (!fTrapConfig) {
1806 AliWarning("Falling back to default configuration");
1807 fTrapConfig = new AliTRDtrapConfig("default", "default TRAP configuration");
1808 AliTRDtrapConfigHandler cfgHandler(fTrapConfig);
1809 cfgHandler.Init();
1810 cfgHandler.LoadConfig();
1811 }
1812
1813 AliInfo(Form("using TRAPconfig \"%s\"", fTrapConfig->GetTitle()));
1814
1815 return fTrapConfig;
1816 }
1817}
1818
1819
1820AliTRDtrapConfig* AliTRDcalibDB::LoadTrapConfig(const TString &name, const TString &version)
1821{
1822 // try to load the specified configuration from the OCDB
1823 // if it fails, or it does not exist, return null
1824
1825 AliInfo(Form("looking for TRAPconfig \"%s.%s\"", name.Data(), version.Data()));
1826
1827 const AliTRDCalTrapConfig *caltrap = dynamic_cast<const AliTRDCalTrapConfig*> (GetCachedCDBObject(kIDTrapConfig));
1828
1829 if (caltrap) {
1830 TString configName(name);
1831 configName.Append(".");
1832 configName.Append(version);
1833 fTrapConfig = caltrap->Get(configName);
1834 }
1835 else {
1836 fTrapConfig = 0x0;
1837 AliError("No TRAPconfig entry found!");
1838 }
1839
1840 return fTrapConfig;
1841}