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