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 <TMath.h>
  32 #include <TRandom.h>
  33
  34 #include "AliCDBManager.h"
  35 #include "AliCDBStorage.h"
  36 #include "AliCDBEntry.h"
  37 #include "AliLog.h"
  38
  39 #include "AliTRDcalibDB.h"
  40 #include "AliTRDgeometry.h"
  41 #include "AliTRDpadPlane.h"
  42 #include "AliTRDCommonParam.h"
  43
  44 #include "Cal/AliTRDCalROC.h"
  45 #include "Cal/AliTRDCalPad.h"
  46 #include "Cal/AliTRDCalDet.h"
  47 #include "Cal/AliTRDCalGlobals.h"
  48 #include "Cal/AliTRDCalPIDLQ.h"
  49 #include "Cal/AliTRDCalMonitoring.h"
  50 #include "Cal/AliTRDCalSuperModuleStatus.h"
  51 #include "Cal/AliTRDCalChamberStatus.h"
  52 #include "Cal/AliTRDCalMCMStatus.h"
  53 #include "Cal/AliTRDCalPadStatus.h"
  54 #include "Cal/AliTRDCalSingleChamberStatus.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 {
 111   //
 112   // Default constructor
 113   //
 114   // TODO Default runnumber is set to 0, this should be changed later
 115   //      to an invalid value (e.g. -1) to prevent
 116   // TODO invalid calibration data to be used.
 117   //
 118
 119   for (Int_t i = 0; i < kCDBCacheSize; ++i) {
 120     fCDBCache[i]   = 0;
 121     fCDBEntries[i] = 0;
 122   }
 123
 124   // Create the sampled PRF
 125   SamplePRF();
 126
 127 }
 128
 129 //_____________________________________________________________________________
 130 AliTRDcalibDB::AliTRDcalibDB(const AliTRDcalibDB &c)
 131   :TObject(c)
 132   ,fRun(-1)
 133   ,fPRFsmp(0)
 134   ,fPRFbin(0)
 135   ,fPRFlo(0)
 136   ,fPRFhi(0)
 137   ,fPRFwid(0)
 138   ,fPRFpad(0)
 139 {
 140   //
 141   // Copy constructor (not that it make any sense for a singleton...)
 142   //
 143
 144   for (Int_t i = 0; i < kCDBCacheSize; ++i) {
 145     fCDBCache[i]   = 0;
 146     fCDBEntries[i] = 0;
 147   }
 148
 149   // Create the sampled PRF
 150   SamplePRF();
 151
 152 }
 153
 154 //_____________________________________________________________________________
 155 AliTRDcalibDB &AliTRDcalibDB::operator=(const AliTRDcalibDB &c)
 156 {
 157   //
 158   // Assignment operator (same as above ...)
 159   //
 160
 161   if (this != &c) {
 162     AliFatal("No assignment operator defined");
 163   }
 164
 165   return *this;
 166
 167 }
 168
 169 //_____________________________________________________________________________
 170 AliTRDcalibDB::~AliTRDcalibDB()
 171 {
 172   //
 173   // destructor
 174   //
 175
 176   if (fPRFsmp) {
 177     delete [] fPRFsmp;
 178     fPRFsmp = 0;
 179   }
 180
 181   Invalidate();
 182
 183 }
 184
 185 //_caching functions____________________________________________________________
 186 const TObject *AliTRDcalibDB::GetCachedCDBObject(Int_t id)
 187 {
 188   //
 189   // Retrieves a cdb object with the given id. The objects are cached as
 190   // long as the run number is not changed.
 191   //
 192   // Put together the available objects here by using the lines
 193   //   a) For usual calibration objects:
 194   //      case kID<Name> :
 195   //        return CacheCDBEntry(kID<Name>,"TRD/Calib/<Path>");
 196   //        break;
 197   //      See function CacheCDBEntry for details.
 198   //   and
 199   //   b) For calibration data which depends on two objects: One containing
 200   //      a value per detector and one the local fluctuations per pad:
 201   //      case kID<Name> :
 202   //        return CacheMergeCDBEntry(kID<Name>,"TRD/Calib/<padPath>","TRD/Calib/<chamberPath>");
 203   //        break;
 204   //      See function CacheMergeCDBEntry for details.
 205   //
 206
 207   switch (id) {
 208
 209     // Parameters defined per pad and chamber
 210     case kIDVdriftPad :
 211       return CacheCDBEntry(kIDVdriftPad         ,"TRD/Calib/LocalVdrift");
 212       break;
 213     case kIDVdriftChamber :
 214       return CacheCDBEntry(kIDVdriftChamber     ,"TRD/Calib/ChamberVdrift");
 215       break;
 216     case kIDT0Pad :
 217       return CacheCDBEntry(kIDT0Pad             ,"TRD/Calib/LocalT0");
 218       break;
 219     case kIDT0Chamber :
 220       return CacheCDBEntry(kIDT0Chamber         ,"TRD/Calib/ChamberT0");
 221       break;
 222     case kIDGainFactorPad :
 223       return CacheCDBEntry(kIDGainFactorPad     ,"TRD/Calib/LocalGainFactor");
 224       break;
 225     case kIDGainFactorChamber :
 226       return CacheCDBEntry(kIDGainFactorChamber ,"TRD/Calib/ChamberGainFactor");
 227       break;
 228
 229     // Parameters defined per pad
 230     case kIDPRFWidth :
 231       return CacheCDBEntry(kIDPRFWidth          ,"TRD/Calib/PRFWidth");
 232       break;
 233
 234     // Status values
 235     case kIDSuperModuleStatus :
 236       return CacheCDBEntry(kIDSuperModuleStatus ,"TRD/Calib/SuperModuleStatus");
 237       break;
 238     case kIDChamberStatus :
 239       return CacheCDBEntry(kIDChamberStatus     ,"TRD/Calib/ChamberStatus");
 240       break;
 241     case kIDMCMStatus :
 242       return CacheCDBEntry(kIDMCMStatus         ,"TRD/Calib/MCMStatus");
 243       break;
 244     case kIDPadStatus :
 245       return CacheCDBEntry(kIDPadStatus         ,"TRD/Calib/PadStatus");
 246       break;
 247
 248     // Global parameters
 249     case kIDMonitoringData :
 250       return CacheCDBEntry(kIDMonitoringData    ,"TRD/Calib/MonitoringData");
 251       break;
 252     case kIDGlobals :
 253       return CacheCDBEntry(kIDGlobals           ,"TRD/Calib/Globals");
 254       break;
 255     case kIDPIDLQ :
 256       return CacheCDBEntry(kIDPIDLQ             ,"TRD/Calib/PIDLQ");
 257       break;
 258
 259   }
 260
 261   return 0;
 262
 263 }
 264
 265 //_____________________________________________________________________________
 266 AliCDBEntry *AliTRDcalibDB::GetCDBEntry(const char *cdbPath)
 267 {
 268   //
 269   // Retrieves an entry with path <cdbPath> from the CDB.
 270   //
 271
 272   AliCDBEntry *entry = AliCDBManager::Instance()->Get(cdbPath,fRun);
 273   if (!entry) {
 274     AliError(Form("Failed to get entry: %s",cdbPath));
 275     return 0;
 276   }
 277
 278   return entry;
 279
 280 }
 281
 282 //_____________________________________________________________________________
 283 const TObject *AliTRDcalibDB::CacheCDBEntry(Int_t id, const char *cdbPath)
 284 {
 285   //
 286   // Caches the entry <id> with cdb path <cdbPath>
 287   //
 288
 289   if (!fCDBCache[id]) {
 290     fCDBEntries[id] = GetCDBEntry(cdbPath);
 291     if (fCDBEntries[id]) {
 292       fCDBCache[id] = fCDBEntries[id]->GetObject();
 293     }
 294   }
 295
 296   return fCDBCache[id];
 297
 298 }
 299
 300 //_____________________________________________________________________________
 301 void AliTRDcalibDB::SetRun(Long64_t run)
 302 {
 303   //
 304   // Sets current run number. Calibration data is read from the corresponding file.
 305   // When the run number changes the caching is invalidated.
 306   //
 307
 308   if (fRun == run) {
 309     return;
 310   }
 311
 312   fRun = run;
 313
 314   Invalidate();
 315
 316 }
 317
 318 //_____________________________________________________________________________
 319 void AliTRDcalibDB::Invalidate()
 320 {
 321   //
 322   // Invalidates cache (when run number is changed).
 323   //
 324
 325   for (Int_t i = 0; i < kCDBCacheSize; ++i) {
 326     if (fCDBEntries[i]) {
 327       if (AliCDBManager::Instance()->GetCacheFlag() == kFALSE) {
 328         if ((fCDBEntries[i]->IsOwner() == kFALSE) && fCDBCache[i]) {
 329           delete fCDBCache[i];
 330         }
 331         delete fCDBEntries[i];
 332       }
 333       fCDBEntries[i] = 0;
 334       fCDBCache[i]   = 0;
 335     }
 336   }
 337
 338 }
 339
 340 //_____________________________________________________________________________
 341 Float_t AliTRDcalibDB::GetVdrift(Int_t det, Int_t col, Int_t row)
 342 {
 343   //
 344   // Returns the drift velocity for the given pad.
 345   //
 346
 347   const AliTRDCalPad *calPad     = dynamic_cast<const AliTRDCalPad *>
 348                                    (GetCachedCDBObject(kIDVdriftPad));
 349   if (!calPad) {
 350     return -1;
 351   }
 352
 353   AliTRDCalROC       *roc        = calPad->GetCalROC(det);
 354   if (!roc) {
 355     return -1;
 356   }
 357
 358   const AliTRDCalDet *calChamber = dynamic_cast<const AliTRDCalDet *>
 359                                    (GetCachedCDBObject(kIDVdriftChamber));
 360   if (!calChamber) {
 361     return -1;
 362   }
 363
 364   return calChamber->GetValue(det) * roc->GetValue(col,row);
 365
 366 }
 367
 368 //_____________________________________________________________________________
 369 Float_t AliTRDcalibDB::GetVdriftAverage(Int_t det)
 370 {
 371   //
 372   // Returns the average drift velocity for the given detector
 373   //
 374
 375   const AliTRDCalDet *calDet     = dynamic_cast<const AliTRDCalDet *>
 376                                    (GetCachedCDBObject(kIDVdriftChamber));
 377   if (!calDet) {
 378     return -1;
 379   }
 380
 381   return calDet->GetValue(det);
 382
 383 }
 384
 385 //_____________________________________________________________________________
 386 Float_t AliTRDcalibDB::GetT0(Int_t det, Int_t col, Int_t row)
 387 {
 388   //
 389   // Returns t0 for the given pad.
 390   //
 391
 392   const AliTRDCalPad *calPad     = dynamic_cast<const AliTRDCalPad *>
 393                                    (GetCachedCDBObject(kIDT0Pad));
 394   if (!calPad) {
 395     return -1;
 396   }
 397
 398   AliTRDCalROC       *roc        = calPad->GetCalROC(det);
 399   if (!roc) {
 400     return -1;
 401   }
 402
 403   const AliTRDCalDet *calChamber = dynamic_cast<const AliTRDCalDet *>
 404                                    (GetCachedCDBObject(kIDT0Chamber));
 405   if (!calChamber) {
 406     return -1;
 407   }
 408
 409   return calChamber->GetValue(det) * roc->GetValue(col,row);
 410
 411 }
 412
 413 //_____________________________________________________________________________
 414 Float_t AliTRDcalibDB::GetT0Average(Int_t det)
 415 {
 416   //
 417   // Returns the average t0 for the given detector
 418   //
 419
 420   const AliTRDCalDet *calDet     = dynamic_cast<const AliTRDCalDet *>
 421                                    (GetCachedCDBObject(kIDT0Chamber));
 422   if (!calDet) {
 423     return -1;
 424   }
 425
 426   return calDet->GetValue(det);
 427
 428 }
 429
 430 //_____________________________________________________________________________
 431 Float_t AliTRDcalibDB::GetGainFactor(Int_t det, Int_t col, Int_t row)
 432 {
 433   //
 434   // Returns the gain factor for the given pad.
 435   //
 436
 437   const AliTRDCalPad *calPad     = dynamic_cast<const AliTRDCalPad *>
 438                                    (GetCachedCDBObject(kIDGainFactorPad));
 439   if (!calPad) {
 440     return -1;
 441   }
 442
 443   AliTRDCalROC       *roc        = calPad->GetCalROC(det);
 444   if (!roc)
 445     return -1;
 446
 447   const AliTRDCalDet *calChamber = dynamic_cast<const AliTRDCalDet *>
 448                                    (GetCachedCDBObject(kIDGainFactorChamber));
 449   if (!calChamber) {
 450     return -1;
 451   }
 452
 453   return calChamber->GetValue(det) * roc->GetValue(col,row);
 454
 455 }
 456
 457 //_____________________________________________________________________________
 458 Float_t AliTRDcalibDB::GetGainFactorAverage(Int_t det)
 459 {
 460   //
 461   // Returns the average gain factor for the given detector
 462   //
 463
 464   const AliTRDCalDet *calDet     = dynamic_cast<const AliTRDCalDet *>
 465                                    (GetCachedCDBObject(kIDGainFactorChamber));
 466   if (!calDet) {
 467     return -1;
 468   }
 469
 470   return calDet->GetValue(det);
 471
 472 }
 473
 474 //_____________________________________________________________________________
 475 Float_t AliTRDcalibDB::GetPRFWidth(Int_t det, Int_t col, Int_t row)
 476 {
 477   //
 478   // Returns the PRF width for the given pad.
 479   //
 480
 481   const AliTRDCalPad *calPad     = dynamic_cast<const AliTRDCalPad *>
 482                                    (GetCachedCDBObject(kIDPRFWidth));
 483   if (!calPad) {
 484     return -1;
 485   }
 486
 487   AliTRDCalROC       *roc        = calPad->GetCalROC(det);
 488   if (!roc) {
 489     return -1;
 490   }
 491
 492   return roc->GetValue(col,row);
 493
 494 }
 495
 496 //_____________________________________________________________________________
 497 Float_t AliTRDcalibDB::GetSamplingFrequency()
 498 {
 499   //
 500   // Returns the sampling frequency of the TRD read-out.
 501   //
 502
 503   const AliTRDCalGlobals *calGlobal = dynamic_cast<const AliTRDCalGlobals *>
 504                                       (GetCachedCDBObject(kIDGlobals));
 505   if (!calGlobal) {
 506     return -1;
 507   }
 508
 509   return calGlobal->GetSamplingFrequency();
 510
 511 }
 512
 513 //_____________________________________________________________________________
 514 Int_t AliTRDcalibDB::GetNumberOfTimeBins()
 515 {
 516   //
 517   // Returns the number of time bins which are read-out.
 518   //
 519
 520   const AliTRDCalGlobals *calGlobal = dynamic_cast<const AliTRDCalGlobals *>
 521                                       (GetCachedCDBObject(kIDGlobals));
 522   if (!calGlobal) {
 523     return -1;
 524   }
 525
 526   return calGlobal->GetNumberOfTimeBins();
 527
 528 }
 529
 530 //_____________________________________________________________________________
 531 Char_t AliTRDcalibDB::GetPadStatus(Int_t det, Int_t col, Int_t row)
 532 {
 533   //
 534   // Returns the status of the given pad
 535   //
 536
 537   const AliTRDCalPadStatus *cal     = dynamic_cast<const AliTRDCalPadStatus *>
 538                                       (GetCachedCDBObject(kIDPadStatus));
 539   if (!cal) {
 540     return -1;
 541   }
 542
 543   const AliTRDCalSingleChamberStatus *roc = cal->GetCalROC(det);
 544   if (!roc) {
 545     return -1;
 546   }
 547
 548   return roc->GetStatus(col,row);
 549
 550 }
 551
 552 //_____________________________________________________________________________
 553 Char_t AliTRDcalibDB::GetMCMStatus(Int_t det, Int_t col, Int_t row)
 554 {
 555   //
 556   // Returns the status of the given MCM
 557   //
 558
 559   const AliTRDCalMCMStatus *cal     = dynamic_cast<const AliTRDCalMCMStatus *>
 560                                       (GetCachedCDBObject(kIDMCMStatus));
 561   if (!cal) {
 562     return -1;
 563   }
 564
 565   return cal->GetStatus(det,col,row);
 566
 567 }
 568
 569 //_____________________________________________________________________________
 570 Char_t AliTRDcalibDB::GetChamberStatus(Int_t det)
 571 {
 572   //
 573   // Returns the status of the given chamber
 574   //
 575
 576   const AliTRDCalChamberStatus *cal = dynamic_cast<const AliTRDCalChamberStatus *>
 577                                       (GetCachedCDBObject(kIDChamberStatus));
 578   if (!cal) {
 579     return -1;
 580   }
 581
 582   return cal->GetStatus(det);
 583
 584 }
 585
 586 //_____________________________________________________________________________
 587 Char_t AliTRDcalibDB::GetSuperModuleStatus(Int_t sm)
 588 {
 589   //
 590   // Returns the status of the given chamber
 591   //
 592
 593   const AliTRDCalSuperModuleStatus *cal = dynamic_cast<const AliTRDCalSuperModuleStatus *>
 594                                           (GetCachedCDBObject(kIDSuperModuleStatus));
 595   if (!cal) {
 596     return -1;
 597   }
 598
 599   return cal->GetStatus(sm);
 600
 601 }
 602
 603 //_____________________________________________________________________________
 604 Bool_t AliTRDcalibDB::IsPadMasked(Int_t det, Int_t col, Int_t row)
 605 {
 606   //
 607   // Returns status, see name of functions for details ;-)
 608   //
 609
 610   const AliTRDCalPadStatus         *cal = dynamic_cast<const AliTRDCalPadStatus *>
 611                                           (GetCachedCDBObject(kIDPadStatus));
 612   if (!cal) {
 613     return -1;
 614   }
 615
 616   return cal->IsMasked(det,col,row);
 617
 618 }
 619
 620 //_____________________________________________________________________________
 621 Bool_t AliTRDcalibDB::IsPadBridgedLeft(Int_t det, Int_t col, Int_t row)
 622 {
 623   //
 624   // Returns status, see name of functions for details ;-)
 625   //
 626
 627   const AliTRDCalPadStatus         *cal = dynamic_cast<const AliTRDCalPadStatus *>
 628                                           (GetCachedCDBObject(kIDPadStatus));
 629   if (!cal) {
 630     return -1;
 631   }
 632
 633   return cal->IsBridgedLeft(det,col,row);
 634
 635 }
 636
 637 //_____________________________________________________________________________
 638 Bool_t AliTRDcalibDB::IsPadBridgedRight(Int_t det, Int_t col, Int_t row)
 639 {
 640   //
 641   // Returns status, see name of functions for details ;-)
 642   //
 643
 644   const AliTRDCalPadStatus         * cal = dynamic_cast<const AliTRDCalPadStatus *>
 645                                            (GetCachedCDBObject(kIDPadStatus));
 646   if (!cal) {
 647     return -1;
 648   }
 649
 650   return cal->IsBridgedRight(det,col,row);
 651
 652 }
 653
 654 //_____________________________________________________________________________
 655 Bool_t AliTRDcalibDB::IsMCMMasked(Int_t det, Int_t col, Int_t row)
 656 {
 657   //
 658   // Returns status, see name of functions for details ;-)
 659   //
 660
 661   const AliTRDCalMCMStatus         * cal = dynamic_cast<const AliTRDCalMCMStatus *>
 662                                            (GetCachedCDBObject(kIDMCMStatus));
 663   if (!cal) {
 664     return -1;
 665   }
 666
 667   return cal->IsMasked(det,col,row);
 668
 669 }
 670
 671 //_____________________________________________________________________________
 672 Bool_t AliTRDcalibDB::IsChamberInstalled(Int_t det)
 673 {
 674   //
 675   // Returns status, see name of functions for details ;-)
 676   //
 677
 678   const AliTRDCalChamberStatus     * cal = dynamic_cast<const AliTRDCalChamberStatus *>
 679                                            (GetCachedCDBObject(kIDChamberStatus));
 680   if (!cal) {
 681     return -1;
 682   }
 683
 684   return cal->IsInstalled(det);
 685
 686 }
 687
 688 //_____________________________________________________________________________
 689 Bool_t AliTRDcalibDB::IsChamberMasked(Int_t det)
 690 {
 691   //
 692   // Returns status, see name of functions for details ;-)
 693   //
 694
 695   const AliTRDCalChamberStatus     * cal = dynamic_cast<const AliTRDCalChamberStatus *>
 696                                            (GetCachedCDBObject(kIDChamberStatus));
 697   if (!cal) {
 698     return -1;
 699   }
 700
 701   return cal->IsMasked(det);
 702
 703 }
 704
 705 //_____________________________________________________________________________
 706 Bool_t AliTRDcalibDB::IsSuperModuleInstalled(Int_t det)
 707 {
 708   //
 709   // Returns status, see name of functions for details ;-)
 710   //
 711
 712   const AliTRDCalSuperModuleStatus * cal = dynamic_cast<const AliTRDCalSuperModuleStatus *>
 713                                            (GetCachedCDBObject(kIDSuperModuleStatus));
 714   if (!cal) {
 715     return -1;
 716   }
 717
 718   return cal->IsInstalled(det);
 719
 720 }
 721
 722 //_____________________________________________________________________________
 723 Bool_t AliTRDcalibDB::IsSuperModuleMasked(Int_t det)
 724 {
 725   //
 726   // Returns status, see name of functions for details ;-)
 727   //
 728
 729   const AliTRDCalSuperModuleStatus * cal = dynamic_cast<const AliTRDCalSuperModuleStatus *>
 730                                            (GetCachedCDBObject(kIDSuperModuleStatus));
 731   if (!cal) {
 732     return -1;
 733   }
 734
 735   return cal->IsMasked(det);
 736
 737 }
 738
 739 //_____________________________________________________________________________
 740 const AliTRDCalPIDLQ* AliTRDcalibDB::GetPIDLQObject()
 741 {
 742   //
 743   // Returns the object storing the distributions for PID with likelihood
 744   //
 745
 746   return dynamic_cast<const AliTRDCalPIDLQ *> (GetCachedCDBObject(kIDPIDLQ));
 747
 748 }
 749
 750 //_____________________________________________________________________________
 751 const AliTRDCalMonitoring* AliTRDcalibDB::GetMonitoringObject()
 752 {
 753   //
 754   // Returns the object storing the monitoring data
 755   //
 756
 757   return dynamic_cast<const AliTRDCalMonitoring *> (GetCachedCDBObject(kIDMonitoringData));
 758
 759 }
 760
 761 //_____________________________________________________________________________
 762 Float_t AliTRDcalibDB::GetOmegaTau(Float_t vdrift, Float_t bz)
 763 {
 764   //
 765   // Returns omega*tau (tan(Lorentz-angle)) for a given drift velocity <vdrift>
 766   // and a B-field <bz> for Xe/CO2 (15%).
 767   // The values are according to a GARFIELD simulation.
 768   //
 769   // This function basically does not belong to the calibration class.
 770   // It should be moved somewhere else.
 771   // However, currently it is in use by simulation and reconstruction.
 772   //
 773
 774   Float_t fieldAbs = TMath::Abs(bz);
 775   Float_t fieldSgn = (bz > 0.0) ? 1.0 : -1.0;
 776
 777   const Int_t kNb = 5;
 778   Float_t p0[kNb] = {  0.004810,  0.007412,  0.010252,  0.013409,  0.016888 };
 779   Float_t p1[kNb] = {  0.054875,  0.081534,  0.107333,  0.131983,  0.155455 };
 780   Float_t p2[kNb] = { -0.008682, -0.012896, -0.016987, -0.020880, -0.024623 };
 781   Float_t p3[kNb] = {  0.000155,  0.000238,  0.000330,  0.000428,  0.000541 };
 782
 783   // No ExB if field is too small (or zero)
 784   if (fieldAbs < 0.01) {
 785
 786     return 0.0;
 787
 788   }
 789   // Calculate ExB from parametrization
 790   else {
 791
 792     Int_t ib = ((Int_t) (10 * (fieldAbs - 0.15)));
 793     ib       = TMath::Max(  0,ib);
 794     ib       = TMath::Min(kNb,ib);
 795
 796     Float_t alphaL = p0[ib]
 797                    + p1[ib] * vdrift
 798                    + p2[ib] * vdrift*vdrift
 799                    + p3[ib] * vdrift*vdrift*vdrift;
 800
 801     return TMath::Tan(fieldSgn * alphaL);
 802
 803   }
 804
 805 }
 806
 807 //_____________________________________________________________________________
 808 void AliTRDcalibDB::SamplePRF()
 809 {
 810   //
 811   // Samples the pad response function (should maybe go somewhere else ...)
 812   //
 813
 814   const Int_t kPRFbin = 61;
 815
 816   Float_t prf[kNplan][kPRFbin] = {
 817                    {2.9037e-02, 3.3608e-02, 3.9020e-02, 4.5292e-02,
 818                     5.2694e-02, 6.1362e-02, 7.1461e-02, 8.3362e-02,
 819                     9.7063e-02, 1.1307e-01, 1.3140e-01, 1.5235e-01,
 820                     1.7623e-01, 2.0290e-01, 2.3294e-01, 2.6586e-01,
 821                     3.0177e-01, 3.4028e-01, 3.8077e-01, 4.2267e-01,
 822                     4.6493e-01, 5.0657e-01, 5.4655e-01, 5.8397e-01,
 823                     6.1767e-01, 6.4744e-01, 6.7212e-01, 6.9188e-01,
 824                     7.0627e-01, 7.1499e-01, 7.1851e-01, 7.1499e-01,
 825                     7.0627e-01, 6.9188e-01, 6.7212e-01, 6.4744e-01,
 826                     6.1767e-01, 5.8397e-01, 5.4655e-01, 5.0657e-01,
 827                     4.6493e-01, 4.2267e-01, 3.8077e-01, 3.4028e-01,
 828                     3.0177e-01, 2.6586e-01, 2.3294e-01, 2.0290e-01,
 829                     1.7623e-01, 1.5235e-01, 1.3140e-01, 1.1307e-01,
 830                     9.7063e-02, 8.3362e-02, 7.1461e-02, 6.1362e-02,
 831                     5.2694e-02, 4.5292e-02, 3.9020e-02, 3.3608e-02,
 832                     2.9037e-02},
 833                    {2.5478e-02, 2.9695e-02, 3.4655e-02, 4.0454e-02,
 834                     4.7342e-02, 5.5487e-02, 6.5038e-02, 7.6378e-02,
 835                     8.9696e-02, 1.0516e-01, 1.2327e-01, 1.4415e-01,
 836                     1.6794e-01, 1.9516e-01, 2.2573e-01, 2.5959e-01,
 837                     2.9694e-01, 3.3719e-01, 3.7978e-01, 4.2407e-01,
 838                     4.6889e-01, 5.1322e-01, 5.5569e-01, 5.9535e-01,
 839                     6.3141e-01, 6.6259e-01, 6.8882e-01, 7.0983e-01,
 840                     7.2471e-01, 7.3398e-01, 7.3761e-01, 7.3398e-01,
 841                     7.2471e-01, 7.0983e-01, 6.8882e-01, 6.6259e-01,
 842                     6.3141e-01, 5.9535e-01, 5.5569e-01, 5.1322e-01,
 843                     4.6889e-01, 4.2407e-01, 3.7978e-01, 3.3719e-01,
 844                     2.9694e-01, 2.5959e-01, 2.2573e-01, 1.9516e-01,
 845                     1.6794e-01, 1.4415e-01, 1.2327e-01, 1.0516e-01,
 846                     8.9696e-02, 7.6378e-02, 6.5038e-02, 5.5487e-02,
 847                     4.7342e-02, 4.0454e-02, 3.4655e-02, 2.9695e-02,
 848                     2.5478e-02},
 849                    {2.2363e-02, 2.6233e-02, 3.0782e-02, 3.6140e-02,
 850                     4.2535e-02, 5.0157e-02, 5.9197e-02, 6.9900e-02,
 851                     8.2707e-02, 9.7811e-02, 1.1548e-01, 1.3601e-01,
 852                     1.5998e-01, 1.8739e-01, 2.1840e-01, 2.5318e-01,
 853                     2.9182e-01, 3.3373e-01, 3.7837e-01, 4.2498e-01,
 854                     4.7235e-01, 5.1918e-01, 5.6426e-01, 6.0621e-01,
 855                     6.4399e-01, 6.7700e-01, 7.0472e-01, 7.2637e-01,
 856                     7.4206e-01, 7.5179e-01, 7.5551e-01, 7.5179e-01,
 857                     7.4206e-01, 7.2637e-01, 7.0472e-01, 6.7700e-01,
 858                     6.4399e-01, 6.0621e-01, 5.6426e-01, 5.1918e-01,
 859                     4.7235e-01, 4.2498e-01, 3.7837e-01, 3.3373e-01,
 860                     2.9182e-01, 2.5318e-01, 2.1840e-01, 1.8739e-01,
 861                     1.5998e-01, 1.3601e-01, 1.1548e-01, 9.7811e-02,
 862                     8.2707e-02, 6.9900e-02, 5.9197e-02, 5.0157e-02,
 863                     4.2535e-02, 3.6140e-02, 3.0782e-02, 2.6233e-02,
 864                     2.2363e-02},
 865                    {1.9635e-02, 2.3167e-02, 2.7343e-02, 3.2293e-02,
 866                     3.8224e-02, 4.5335e-02, 5.3849e-02, 6.4039e-02,
 867                     7.6210e-02, 9.0739e-02, 1.0805e-01, 1.2841e-01,
 868                     1.5216e-01, 1.7960e-01, 2.1099e-01, 2.4671e-01,
 869                     2.8647e-01, 3.2996e-01, 3.7660e-01, 4.2547e-01,
 870                     4.7536e-01, 5.2473e-01, 5.7215e-01, 6.1632e-01,
 871                     6.5616e-01, 6.9075e-01, 7.1939e-01, 7.4199e-01,
 872                     7.5838e-01, 7.6848e-01, 7.7227e-01, 7.6848e-01,
 873                     7.5838e-01, 7.4199e-01, 7.1939e-01, 6.9075e-01,
 874                     6.5616e-01, 6.1632e-01, 5.7215e-01, 5.2473e-01,
 875                     4.7536e-01, 4.2547e-01, 3.7660e-01, 3.2996e-01,
 876                     2.8647e-01, 2.4671e-01, 2.1099e-01, 1.7960e-01,
 877                     1.5216e-01, 1.2841e-01, 1.0805e-01, 9.0739e-02,
 878                     7.6210e-02, 6.4039e-02, 5.3849e-02, 4.5335e-02,
 879                     3.8224e-02, 3.2293e-02, 2.7343e-02, 2.3167e-02,
 880                     1.9635e-02},
 881                    {1.7224e-02, 2.0450e-02, 2.4286e-02, 2.8860e-02,
 882                     3.4357e-02, 4.0979e-02, 4.8966e-02, 5.8612e-02,
 883                     7.0253e-02, 8.4257e-02, 1.0102e-01, 1.2094e-01,
 884                     1.4442e-01, 1.7196e-01, 2.0381e-01, 2.4013e-01,
 885                     2.8093e-01, 3.2594e-01, 3.7450e-01, 4.2563e-01,
 886                     4.7796e-01, 5.2991e-01, 5.7974e-01, 6.2599e-01,
 887                     6.6750e-01, 7.0344e-01, 7.3329e-01, 7.5676e-01,
 888                     7.7371e-01, 7.8410e-01, 7.8793e-01, 7.8410e-01,
 889                     7.7371e-01, 7.5676e-01, 7.3329e-01, 7.0344e-01,
 890                     6.6750e-01, 6.2599e-01, 5.7974e-01, 5.2991e-01,
 891                     4.7796e-01, 4.2563e-01, 3.7450e-01, 3.2594e-01,
 892                     2.8093e-01, 2.4013e-01, 2.0381e-01, 1.7196e-01,
 893                     1.4442e-01, 1.2094e-01, 1.0102e-01, 8.4257e-02,
 894                     7.0253e-02, 5.8612e-02, 4.8966e-02, 4.0979e-02,
 895                     3.4357e-02, 2.8860e-02, 2.4286e-02, 2.0450e-02,
 896                     1.7224e-02},
 897                    {1.5096e-02, 1.8041e-02, 2.1566e-02, 2.5793e-02,
 898                     3.0886e-02, 3.7044e-02, 4.4515e-02, 5.3604e-02,
 899                     6.4668e-02, 7.8109e-02, 9.4364e-02, 1.1389e-01,
 900                     1.3716e-01, 1.6461e-01, 1.9663e-01, 2.3350e-01,
 901                     2.7527e-01, 3.2170e-01, 3.7214e-01, 4.2549e-01,
 902                     4.8024e-01, 5.3460e-01, 5.8677e-01, 6.3512e-01,
 903                     6.7838e-01, 7.1569e-01, 7.4655e-01, 7.7071e-01,
 904                     7.8810e-01, 7.9871e-01, 8.0255e-01, 7.9871e-01,
 905                     7.8810e-01, 7.7071e-01, 7.4655e-01, 7.1569e-01,
 906                     6.7838e-01, 6.3512e-01, 5.8677e-01, 5.3460e-01,
 907                     4.8024e-01, 4.2549e-01, 3.7214e-01, 3.2170e-01,
 908                     2.7527e-01, 2.3350e-01, 1.9663e-01, 1.6461e-01,
 909                     1.3716e-01, 1.1389e-01, 9.4364e-02, 7.8109e-02,
 910                     6.4668e-02, 5.3604e-02, 4.4515e-02, 3.7044e-02,
 911                     3.0886e-02, 2.5793e-02, 2.1566e-02, 1.8041e-02,
 912                     1.5096e-02}};
 913
 914   // More sampling precision with linear interpolation
 915   fPRFlo  = -1.5;
 916   fPRFhi  =  1.5;
 917   Float_t pad[kPRFbin];
 918   Int_t   sPRFbin = kPRFbin;
 919   Float_t sPRFwid = (fPRFhi - fPRFlo) / ((Float_t) sPRFbin);
 920   for (Int_t iPad = 0; iPad < sPRFbin; iPad++) {
 921     pad[iPad] = ((Float_t) iPad + 0.5) * sPRFwid + fPRFlo;
 922   }
 923   fPRFbin = 500;
 924   fPRFwid = (fPRFhi - fPRFlo) / ((Float_t) fPRFbin);
 925   fPRFpad = ((Int_t) (1.0 / fPRFwid));
 926
 927   if (fPRFsmp) delete [] fPRFsmp;
 928   fPRFsmp = new Float_t[kNplan*fPRFbin];
 929
 930   Int_t   ipos1;
 931   Int_t   ipos2;
 932   Float_t diff;
 933
 934   for (Int_t iPla = 0; iPla < kNplan; iPla++) {
 935
 936     for (Int_t iBin = 0; iBin < fPRFbin; iBin++) {
 937
 938       Float_t bin = (((Float_t) iBin) + 0.5) * fPRFwid + fPRFlo;
 939       ipos1 = ipos2 = 0;
 940       diff  = 0;
 941       do {
 942         diff = bin - pad[ipos2++];
 943       } while ((diff > 0) && (ipos2 < kPRFbin));
 944       if      (ipos2 == kPRFbin) {
 945         fPRFsmp[iPla*fPRFbin+iBin] = prf[iPla][ipos2-1];
 946       }
 947       else if (ipos2 == 1) {
 948         fPRFsmp[iPla*fPRFbin+iBin] = prf[iPla][ipos2-1];
 949       }
 950       else {
 951         ipos2--;
 952         if (ipos2 >= kPRFbin) ipos2 = kPRFbin - 1;
 953         ipos1 = ipos2 - 1;
 954         fPRFsmp[iPla*fPRFbin+iBin] = prf[iPla][ipos2]
 955                                    + diff * (prf[iPla][ipos2] - prf[iPla][ipos1])
 956                                           / sPRFwid;
 957       }
 958
 959     }
 960   }
 961
 962 }
 963
 964 //_____________________________________________________________________________
 965 Int_t AliTRDcalibDB::PadResponse(Double_t signal, Double_t dist
 966                                 , Int_t plane, Double_t *pad) const
 967 {
 968   //
 969   // Applies the pad response
 970   //
 971
 972   Int_t iBin  = ((Int_t) (( - dist - fPRFlo) / fPRFwid));
 973   Int_t iOff  = plane * fPRFbin;
 974
 975   Int_t iBin0 = iBin - fPRFpad + iOff;
 976   Int_t iBin1 = iBin           + iOff;
 977   Int_t iBin2 = iBin + fPRFpad + iOff;
 978
 979   pad[0] = 0.0;
 980   pad[1] = 0.0;
 981   pad[2] = 0.0;
 982   if ((iBin1 >= 0) && (iBin1 < (fPRFbin*kNplan))) {
 983
 984     if (iBin0 >= 0) {
 985       pad[0] = signal * fPRFsmp[iBin0];
 986     }
 987     pad[1] = signal * fPRFsmp[iBin1];
 988     if (iBin2 < (fPRFbin*kNplan)) {
 989       pad[2] = signal * fPRFsmp[iBin2];
 990     }
 991
 992     return 1;
 993
 994   }
 995   else {
 996
 997     return 0;
 998
 999   }
1000
1001 }
1002