MUON/AliMUONCalibrationData.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 #include "AliMUONCalibrationData.h"
  19
  20 #include "AliCDBEntry.h"
  21 #include "AliCDBManager.h"
  22 #include "AliCodeTimer.h"
  23 #include "AliLog.h"
  24 #include "AliMUONRejectList.h"
  25 #include "AliMUONTriggerEfficiencyCells.h"
  26 #include "AliMUONTriggerLut.h"
  27 #include "AliMUONVStore.h"
  28 #include "AliMUONVStore.h"
  29 #include "AliMUONVCalibParam.h"
  30 #include "AliMUONGlobalCrateConfig.h"
  31 #include "AliMUONRegionalTriggerConfig.h"
  32
  33 #include <Riostream.h>
  34 #include <TClass.h>
  35 #include <TMap.h>
  36
  37 //-----------------------------------------------------------------------------
  38 /// \class AliMUONCalibrationData
  39 ///
  40 /// For the moment, this class stores pedestals, gains, hv (for tracker)
  41 /// and lut, masks and efficiencies (for trigger) that are fetched from the CDB.
  42 ///
  43 /// This class is to be considered as a convenience class.
  44 /// Its aim is to ease retrieval of calibration data from the
  45 /// condition database.
  46 ///
  47 /// It acts as a "facade" to a bunch of underlying
  48 /// containers/calibration classes.
  49 ///
  50 /// \author Laurent Aphecetche
  51 //-----------------------------------------------------------------------------
  52
  53 /// \cond CLASSIMP
  54 ClassImp(AliMUONCalibrationData)
  55 /// \endcond
  56
  57 AliMUONVStore* AliMUONCalibrationData::fBypassPedestals(0x0);
  58 AliMUONVStore* AliMUONCalibrationData::fBypassGains(0x0);
  59
  60 //_____________________________________________________________________________
  61 AliMUONCalibrationData::AliMUONCalibrationData(Int_t runNumber,
  62                                                Bool_t deferredInitialization)
  63 : TObject(),
  64 fIsValid(kTRUE),
  65 fRunNumber(runNumber),
  66 fGains(0x0),
  67 fPedestals(0x0),
  68 fHV(0x0),
  69 fTriggerDCS(0x0),
  70 fLocalTriggerBoardMasks(0x0),
  71 fRegionalTriggerConfig(0x0),
  72 fGlobalTriggerCrateConfig(0x0),
  73 fTriggerLut(0x0),
  74 fTriggerEfficiency(0x0),
  75 fCapacitances(0x0),
  76 fNeighbours(0x0),
  77 fOccupancyMap(0x0),
  78 fRejectList(0x0)
  79 {
  80 /// Default ctor.
  81
  82   // If deferredInitialization is false, we read *all* calibrations
  83   // at once.
  84   // So when using this class to access only one kind of calibrations (e.g.
  85   // only pedestals), you should put deferredInitialization to kTRUE, which
  86   // will instruct this object to fetch the data only when neeeded.
  87
  88   if ( deferredInitialization == kFALSE )
  89   {
  90     Gains();
  91     Pedestals();
  92     OccupancyMap();
  93     RejectList();
  94     HV();
  95     TriggerDCS();
  96     LocalTriggerBoardMasks(0);
  97     RegionalTriggerConfig();
  98     GlobalTriggerCrateConfig();
  99     TriggerLut();
 100     TriggerEfficiency();
 101     Capacitances();
 102     Neighbours();
 103   }
 104 }
 105
 106 //_____________________________________________________________________________
 107 AliMUONCalibrationData::~AliMUONCalibrationData()
 108 {
 109   /// Destructor. Note that we're the owner of our pointers.
 110   //PH The owner of the objects is CDB, do not delete them!
 111   //  Reset();
 112 }
 113
 114 //_____________________________________________________________________________
 115 AliMUONVStore*
 116 AliMUONCalibrationData::Capacitances() const
 117 {
 118   /// Create (if needed) and return the internal store for capacitances.
 119
 120   if (!fCapacitances)
 121   {
 122     fCapacitances = CreateCapacitances(fRunNumber);
 123   }
 124   return fCapacitances;
 125 }
 126
 127 //_____________________________________________________________________________
 128 AliMUONVStore*
 129 AliMUONCalibrationData::CreateCapacitances(Int_t runNumber, Int_t* startOfValidity)
 130 {
 131   /// Create capa store from OCDB for a given run
 132
 133   return dynamic_cast<AliMUONVStore*>(CreateObject(runNumber,"MUON/Calib/Capacitances",startOfValidity));
 134 }
 135
 136 //_____________________________________________________________________________
 137 AliMUONVStore*
 138 AliMUONCalibrationData::CreateGains(Int_t runNumber, Int_t* startOfValidity)
 139 {
 140   /// Create a new gain store from the OCDB for a given run
 141   return dynamic_cast<AliMUONVStore*>(CreateObject(runNumber,"MUON/Calib/Gains",startOfValidity));
 142 }
 143
 144 //_____________________________________________________________________________
 145 AliMUONGlobalCrateConfig*
 146 AliMUONCalibrationData::CreateGlobalTriggerCrateConfig(Int_t runNumber, Int_t* startOfValidity)
 147 {
 148   /// Create the internal store for GlobalTriggerCrateConfig from OCDB
 149
 150   return dynamic_cast<AliMUONGlobalCrateConfig*>(CreateObject(runNumber,"MUON/Calib/GlobalTriggerCrateConfig",startOfValidity));
 151 }
 152
 153
 154
 155 //_____________________________________________________________________________
 156 TMap*
 157 AliMUONCalibrationData::CreateHV(Int_t runNumber, Int_t* startOfValidity)
 158 {
 159   /// Create a new HV map from the OCDB for a given run
 160   return dynamic_cast<TMap*>(CreateObject(runNumber,"MUON/Calib/HV",startOfValidity));
 161 }
 162
 163 //_____________________________________________________________________________
 164 TMap*
 165 AliMUONCalibrationData::CreateTriggerDCS(Int_t runNumber, Int_t* startOfValidity)
 166 {
 167   /// Create a new Trigger HV and curent map from the OCDB for a given run
 168   return dynamic_cast<TMap*>(CreateObject(runNumber,"MUON/Calib/TriggerDCS",startOfValidity));
 169 }
 170
 171 //_____________________________________________________________________________
 172 AliMUONVStore*
 173 AliMUONCalibrationData::CreateLocalTriggerBoardMasks(Int_t runNumber, Int_t* startOfValidity)
 174 {
 175   /// Get the internal store for LocalTriggerBoardMasks from OCDB
 176
 177   return dynamic_cast<AliMUONVStore*>(CreateObject(runNumber,"MUON/Calib/LocalTriggerBoardMasks",startOfValidity));
 178 }
 179
 180 //_____________________________________________________________________________
 181 AliMUONVStore*
 182 AliMUONCalibrationData::CreateNeighbours(Int_t runNumber, Int_t* startOfValidity)
 183 {
 184   /// Create a neighbour store from the OCDB for a given run
 185   return dynamic_cast<AliMUONVStore*>(CreateObject(runNumber,"MUON/Calib/Neighbours",startOfValidity));
 186 }
 187
 188 //_____________________________________________________________________________
 189 TObject*
 190 AliMUONCalibrationData::CreateObject(Int_t runNumber, const char* path, Int_t* startOfValidity)
 191 {
 192   /// Access the CDB for a given path (e.g. MUON/Calib/Pedestals),
 193   /// and return the corresponding TObject.
 194
 195   AliCodeTimerAutoClass(Form("%d : %s",runNumber,path));
 196
 197   AliCDBManager* man = AliCDBManager::Instance();
 198
 199   AliCDBEntry* entry =  man->Get(path,runNumber);
 200
 201   if (entry)
 202   {
 203                 if ( startOfValidity ) *startOfValidity = entry->GetId().GetFirstRun();
 204
 205     TObject* object = entry->GetObject();
 206     entry->SetOwner(kFALSE);
 207     if (!(man->GetCacheFlag())) delete entry;
 208     return object;
 209   }
 210         else
 211         {
 212                 if ( startOfValidity )  *startOfValidity = AliCDBRunRange::Infinity();
 213   }
 214
 215   {
 216
 217   AliCodeTimerAutoClass(Form("Failed to get %s for run %d",path,runNumber));
 218
 219   }
 220
 221   return 0x0;
 222 }
 223
 224 //_____________________________________________________________________________
 225 AliMUONVStore*
 226 AliMUONCalibrationData::CreateOccupancyMap(Int_t runNumber, Int_t* startOfValidity)
 227 {
 228   /// Create a new occupancy map store from the OCDB for a given run
 229   return dynamic_cast<AliMUONVStore*>(CreateObject(runNumber,"MUON/Calib/OccupancyMap",startOfValidity));
 230 }
 231
 232 //_____________________________________________________________________________
 233 AliMUONRejectList*
 234 AliMUONCalibrationData::CreateRejectList(Int_t runNumber, Int_t* startOfValidity)
 235 {
 236   /// Create a new rejectlist store from the OCDB for a given run
 237   return dynamic_cast<AliMUONRejectList*>(CreateObject(runNumber,"MUON/Calib/RejectList",startOfValidity));
 238 }
 239
 240 //_____________________________________________________________________________
 241 AliMUONVStore*
 242 AliMUONCalibrationData::CreatePedestals(Int_t runNumber, Int_t* startOfValidity)
 243 {
 244   /// Create a new pedestal store from the OCDB for a given run
 245   return dynamic_cast<AliMUONVStore*>(CreateObject(runNumber,"MUON/Calib/Pedestals",startOfValidity));
 246 }
 247
 248
 249 //_____________________________________________________________________________
 250 AliMUONRegionalTriggerConfig*
 251 AliMUONCalibrationData::CreateRegionalTriggerConfig(Int_t runNumber, Int_t* startOfValidity)
 252 {
 253   /// Create the internal store for RegionalTriggerConfig from OCDB
 254
 255   return dynamic_cast<AliMUONRegionalTriggerConfig*>(CreateObject(runNumber,"MUON/Calib/RegionalTriggerConfig",startOfValidity));
 256 }
 257
 258 //_____________________________________________________________________________
 259 AliMUONTriggerEfficiencyCells*
 260 AliMUONCalibrationData::CreateTriggerEfficiency(Int_t runNumber, Int_t* startOfValidity)
 261 {
 262   /// Create trigger efficiency object from OCBD
 263
 264   return dynamic_cast<AliMUONTriggerEfficiencyCells*>(CreateObject(runNumber,"MUON/Calib/TriggerEfficiency",startOfValidity));
 265 }
 266
 267 //_____________________________________________________________________________
 268 AliMUONTriggerLut*
 269 AliMUONCalibrationData::CreateTriggerLut(Int_t runNumber, Int_t* startOfValidity)
 270 {
 271   /// Create trigger LUT from OCDB
 272
 273   return dynamic_cast<AliMUONTriggerLut*>(CreateObject(runNumber,"MUON/Calib/TriggerLut",startOfValidity));
 274 }
 275
 276 //_____________________________________________________________________________
 277 AliMUONVStore*
 278 AliMUONCalibrationData::Gains() const
 279 {
 280   /// Create (if needed) and return the internal store for gains.
 281   if (fBypassGains) return fBypassGains;
 282
 283   if (!fGains)
 284   {
 285     fGains = CreateGains(fRunNumber);
 286   }
 287   return fGains;
 288 }
 289
 290 //_____________________________________________________________________________
 291 AliMUONVCalibParam*
 292 AliMUONCalibrationData::Gains(Int_t detElemId, Int_t manuId) const
 293 {
 294 /// Return the gains for a given (detElemId, manuId) pair
 295 /// Note that, unlike the DeadChannel case, if the result is 0x0, that's an
 296 /// error (meaning that we should get gains for all channels).
 297
 298   AliMUONVStore* gains = Gains();
 299   if (!gains)
 300   {
 301     return 0x0;
 302   }
 303
 304   return static_cast<AliMUONVCalibParam*>(gains->FindObject(detElemId,manuId));
 305 }
 306
 307 //_____________________________________________________________________________
 308 AliMUONGlobalCrateConfig*
 309 AliMUONCalibrationData::GlobalTriggerCrateConfig() const
 310 {
 311   /// Return the config for the global trigger board.
 312
 313   if (!fGlobalTriggerCrateConfig)
 314   {
 315     fGlobalTriggerCrateConfig = CreateGlobalTriggerCrateConfig(fRunNumber);
 316   }
 317   return fGlobalTriggerCrateConfig;
 318 }
 319
 320
 321 //_____________________________________________________________________________
 322 TMap*
 323 AliMUONCalibrationData::HV() const
 324 {
 325   /// Return the calibration for a given (detElemId, manuId) pair
 326
 327   if (!fHV)
 328   {
 329     fHV = CreateHV(fRunNumber);
 330   }
 331   return fHV;
 332 }
 333
 334 //_____________________________________________________________________________
 335 TMap*
 336 AliMUONCalibrationData::TriggerDCS() const
 337 {
 338   /// Return the calibration for a given (detElemId, manuId) pair
 339
 340   if (!fTriggerDCS)
 341   {
 342     fTriggerDCS = CreateTriggerDCS(fRunNumber);
 343   }
 344   return fTriggerDCS;
 345 }
 346
 347 //_____________________________________________________________________________
 348 AliMUONVStore*
 349 AliMUONCalibrationData::Neighbours() const
 350 {
 351   /// Create (if needed) and return the internal store for neighbours.
 352   if (!fNeighbours)
 353   {
 354     fNeighbours = CreateNeighbours(fRunNumber);
 355   }
 356   return fNeighbours;
 357 }
 358
 359 //_____________________________________________________________________________
 360 AliMUONVCalibParam*
 361 AliMUONCalibrationData::LocalTriggerBoardMasks(Int_t localBoardNumber) const
 362 {
 363 /// Return the masks for a given trigger local board.
 364
 365   if (!fLocalTriggerBoardMasks)
 366   {
 367     fLocalTriggerBoardMasks = CreateLocalTriggerBoardMasks(fRunNumber);
 368   }
 369
 370   if ( fLocalTriggerBoardMasks )
 371   {
 372     AliMUONVCalibParam* ltbm =
 373       static_cast<AliMUONVCalibParam*>(fLocalTriggerBoardMasks->FindObject(localBoardNumber));
 374     if (!ltbm)
 375     {
 376       AliError(Form("Could not get mask for localBoardNumber=%d",localBoardNumber));
 377     }
 378     return ltbm;
 379   }
 380   return 0x0;
 381 }
 382
 383 //_____________________________________________________________________________
 384 AliMUONVStore*
 385 AliMUONCalibrationData::OccupancyMap() const
 386 {
 387   /// Get occupancy map
 388   if (!fOccupancyMap)
 389   {
 390     fOccupancyMap = CreateOccupancyMap(fRunNumber);
 391   }
 392   return fOccupancyMap;
 393 }
 394
 395 //_____________________________________________________________________________
 396 AliMUONRejectList*
 397 AliMUONCalibrationData::RejectList() const
 398 {
 399   /// Get reject list
 400   if (!fRejectList)
 401   {
 402     fRejectList = CreateRejectList(fRunNumber);
 403   }
 404   return fRejectList;
 405 }
 406
 407 //_____________________________________________________________________________
 408 void
 409 AliMUONCalibrationData::BypassStores(AliMUONVStore* ped, AliMUONVStore* gain)
 410 {
 411   /// Force the use of those pedestals and gains
 412   fBypassPedestals = ped;
 413   fBypassGains = gain;
 414
 415 }
 416
 417 //_____________________________________________________________________________
 418 AliMUONVStore*
 419 AliMUONCalibrationData::Pedestals() const
 420 {
 421   /// Return pedestals
 422
 423   if (fBypassPedestals) return fBypassPedestals;
 424
 425   if (!fPedestals)
 426   {
 427     fPedestals = CreatePedestals(fRunNumber);
 428   }
 429   return fPedestals;
 430 }
 431
 432 //_____________________________________________________________________________
 433 AliMUONVCalibParam*
 434 AliMUONCalibrationData::Pedestals(Int_t detElemId, Int_t manuId) const
 435 {
 436   /// Return the pedestals for a given (detElemId, manuId) pair.
 437   /// A return value of 0x0 is considered an error, meaning we should get
 438   /// pedestals for all channels.
 439
 440   AliMUONVStore* pedestals = Pedestals();
 441   if (!pedestals)
 442   {
 443     return 0x0;
 444   }
 445
 446   return static_cast<AliMUONVCalibParam*>(pedestals->FindObject(detElemId,manuId));
 447 }
 448
 449 //_____________________________________________________________________________
 450 void
 451 AliMUONCalibrationData::Print(Option_t*) const
 452 {
 453   /// A very basic dump of our guts.
 454
 455   cout << "RunNumber " << RunNumber()
 456   << " fGains=" << fGains
 457   << " fPedestals=" << fPedestals
 458   << " fHV=" << fHV
 459   << " fTriggerDCS=" << fTriggerDCS
 460   << " fLocalTriggerBoardMasks=" << fLocalTriggerBoardMasks
 461   << " fRegionalTriggerConfig=" << fRegionalTriggerConfig
 462   << " fGlobalTriggerCrateConfig=" << fGlobalTriggerCrateConfig
 463   << " fTriggerLut=" << fTriggerLut
 464   << endl;
 465 }
 466
 467
 468 //_____________________________________________________________________________
 469 AliMUONRegionalTriggerConfig*
 470 AliMUONCalibrationData::RegionalTriggerConfig() const
 471 {
 472   /// Return the config for the regional trigger board.
 473
 474   if (!fRegionalTriggerConfig)
 475   {
 476     fRegionalTriggerConfig = CreateRegionalTriggerConfig(fRunNumber);
 477     }
 478   return fRegionalTriggerConfig;
 479 }
 480
 481
 482 //_____________________________________________________________________________
 483 AliMUONTriggerEfficiencyCells*
 484 AliMUONCalibrationData::TriggerEfficiency() const
 485 {
 486 /// Return the trigger efficiency.
 487
 488   if (!fTriggerEfficiency)
 489   {
 490     fTriggerEfficiency = CreateTriggerEfficiency(fRunNumber);
 491   }
 492   return fTriggerEfficiency;
 493 }
 494
 495
 496 //_____________________________________________________________________________
 497 AliMUONTriggerLut*
 498 AliMUONCalibrationData::TriggerLut() const
 499 {
 500 /// Return the trigger look up table.
 501
 502   if (!fTriggerLut)
 503   {
 504     fTriggerLut = CreateTriggerLut(fRunNumber);
 505   }
 506   return fTriggerLut;
 507 }
 508
 509 //_____________________________________________________________________________
 510 void
 511 AliMUONCalibrationData::Reset()
 512 {
 513 /// Reset all data
 514
 515   delete fPedestals;
 516   fPedestals = 0x0;
 517   delete fGains;
 518   fGains = 0x0;
 519   delete fHV;
 520   fHV = 0x0;
 521   delete fTriggerDCS;
 522   fTriggerDCS = 0x0;
 523   delete fLocalTriggerBoardMasks;
 524   fLocalTriggerBoardMasks = 0x0;
 525   delete fRegionalTriggerConfig;
 526   fRegionalTriggerConfig = 0x0;
 527   delete fGlobalTriggerCrateConfig;
 528   fGlobalTriggerCrateConfig = 0x0;
 529
 530   delete fTriggerLut;
 531   fTriggerLut = 0x0;
 532   delete fTriggerEfficiency;
 533   fTriggerEfficiency = 0x0;
 534   delete fCapacitances;
 535   fCapacitances = 0x0;
 536   delete fNeighbours;
 537   fNeighbours = 0x0;
 538 }
 539
 540 //_____________________________________________________________________________
 541 void
 542 AliMUONCalibrationData::Check(Int_t runNumber)
 543 {
 544   /// Self-check to see if we can read all data for a given run
 545   /// from the current OCDB...
 546
 547   if ( ! CreateCapacitances(runNumber) )
 548   {
 549     AliErrorClass("Could not read capacitances");
 550   }
 551   else
 552   {
 553     AliInfoClass("Capacitances read OK");
 554   }
 555
 556   if ( ! CreateGains(runNumber) )
 557   {
 558     AliErrorClass("Could not read gains");
 559   }
 560   else
 561   {
 562     AliInfoClass("Gains read OK");
 563   }
 564
 565   if ( ! CreateGlobalTriggerCrateConfig(runNumber) )
 566   {
 567     AliErrorClass("Could not read Trigger Crate Config");
 568   }
 569   else
 570   {
 571     AliInfoClass("TriggerBoardMasks read OK");
 572   }
 573
 574   if ( !  CreateHV(runNumber) )
 575   {
 576     AliErrorClass("Could not read HV");
 577   }
 578   else
 579   {
 580     AliInfoClass("HV read OK");
 581   }
 582
 583   if ( !  CreateTriggerDCS(runNumber) )
 584   {
 585     AliErrorClass("Could not read Trigger HV and Currents");
 586   }
 587   else
 588   {
 589     AliInfoClass("Trigger HV and Currents read OK");
 590   }
 591
 592   if ( ! CreateNeighbours(runNumber) )
 593   {
 594     AliErrorClass("Could not read Neighbours");
 595   }
 596   else
 597   {
 598     AliInfoClass("Neighbours read OK");
 599   }
 600
 601   if ( !  CreateLocalTriggerBoardMasks(runNumber) )
 602   {
 603     AliErrorClass("Could not read LocalTriggerBoardMasks");
 604   }
 605   else
 606   {
 607     AliInfoClass("LocalTriggerBoardMasks read OK");
 608   }
 609
 610   if ( ! CreatePedestals(runNumber) )
 611   {
 612     AliErrorClass("Could not read pedestals");
 613   }
 614   else
 615   {
 616     AliInfoClass("Pedestals read OK");
 617   }
 618
 619   if ( ! CreateRegionalTriggerConfig(runNumber) )
 620   {
 621     AliErrorClass("Could not read RegionalTriggerConfig");
 622   }
 623   else
 624   {
 625     AliInfoClass("RegionalTriggerBoardMasks read OK");
 626   }
 627
 628   if ( ! CreateTriggerLut(runNumber) )
 629   {
 630     AliErrorClass("Could not read TriggerLut");
 631   }
 632   else
 633   {
 634     AliInfoClass("TriggerLut read OK");
 635   }
 636
 637   if ( ! CreateTriggerEfficiency(runNumber) )
 638   {
 639     AliErrorClass("Could not read TriggerEfficiency");
 640   }
 641   else
 642   {
 643     AliInfoClass("TriggerEfficiency read OK");
 644   }
 645 }
 646
 647