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