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 "AliMUONTriggerEfficiencyCells.h"
  25 #include "AliMUONTriggerLut.h"
  26 #include "AliMUONVStore.h"
  27 #include "AliMUONVStore.h"
  28 #include "AliMUONVCalibParam.h"
  29 #include <Riostream.h>
  30 #include <TClass.h>
  31 #include <TMap.h>
  32
  33 //-----------------------------------------------------------------------------
  34 /// \class AliMUONCalibrationData
  35 ///
  36 /// For the moment, this class stores pedestals, gains, hv (for tracker)
  37 /// and lut, masks and efficiencies (for trigger) that are fetched from the CDB.
  38 ///
  39 /// This class is to be considered as a convenience class.
  40 /// Its aim is to ease retrieval of calibration data from the
  41 /// condition database.
  42 ///
  43 /// It acts as a "facade" to a bunch of underlying
  44 /// containers/calibration classes.
  45 ///
  46 /// \author Laurent Aphecetche
  47 //-----------------------------------------------------------------------------
  48
  49 /// \cond CLASSIMP
  50 ClassImp(AliMUONCalibrationData)
  51 /// \endcond
  52
  53 //_____________________________________________________________________________
  54 AliMUONCalibrationData::AliMUONCalibrationData(Int_t runNumber,
  55                                                Bool_t deferredInitialization)
  56 : TObject(),
  57 fIsValid(kTRUE),
  58 fRunNumber(runNumber),
  59 fGains(0x0),
  60 fPedestals(0x0),
  61 fHV(0x0),
  62 fLocalTriggerBoardMasks(0x0),
  63 fRegionalTriggerBoardMasks(0x0),
  64 fGlobalTriggerBoardMasks(0x0),
  65 fTriggerLut(0x0),
  66 fTriggerEfficiency(0x0),
  67 fCapacitances(0x0),
  68 fNeighbours(0x0)
  69 {
  70 /// Default ctor.
  71
  72   // If deferredInitialization is false, we read *all* calibrations
  73   // at once.
  74   // So when using this class to access only one kind of calibrations (e.g.
  75   // only pedestals), you should put deferredInitialization to kTRUE, which
  76   // will instruct this object to fetch the data only when neeeded.
  77
  78   if ( deferredInitialization == kFALSE )
  79   {
  80     Gains();
  81     Pedestals();
  82     HV();
  83     LocalTriggerBoardMasks(0);
  84     RegionalTriggerBoardMasks(0);
  85     GlobalTriggerBoardMasks();
  86     TriggerLut();
  87     TriggerEfficiency();
  88     Capacitances();
  89     Neighbours();
  90   }
  91 }
  92
  93 //_____________________________________________________________________________
  94 AliMUONCalibrationData::~AliMUONCalibrationData()
  95 {
  96   /// Destructor. Note that we're the owner of our pointers.
  97   Reset();
  98 }
  99
 100 //_____________________________________________________________________________
 101 AliMUONVStore*
 102 AliMUONCalibrationData::Capacitances() const
 103 {
 104   /// Create (if needed) and return the internal store for capacitances.
 105
 106   if (!fCapacitances)
 107   {
 108     fCapacitances = CreateCapacitances(fRunNumber);
 109   }
 110   return fCapacitances;
 111 }
 112
 113 //_____________________________________________________________________________
 114 AliMUONVStore*
 115 AliMUONCalibrationData::CreateCapacitances(Int_t runNumber)
 116 {
 117   /// Create capa store from OCDB for a given run
 118
 119   return dynamic_cast<AliMUONVStore*>(CreateObject(runNumber,"MUON/Calib/Capacitances"));
 120 }
 121
 122 //_____________________________________________________________________________
 123 AliMUONVStore*
 124 AliMUONCalibrationData::CreateGains(Int_t runNumber)
 125 {
 126   /// Create a new gain store from the OCDB for a given run
 127   return dynamic_cast<AliMUONVStore*>(CreateObject(runNumber,"MUON/Calib/Gains"));
 128 }
 129
 130 //_____________________________________________________________________________
 131 AliMUONVCalibParam*
 132 AliMUONCalibrationData::CreateGlobalTriggerBoardMasks(Int_t runNumber)
 133 {
 134   /// Create the internal store for GlobalTriggerBoardMasks from OCDB
 135
 136   return dynamic_cast<AliMUONVCalibParam*>(CreateObject(runNumber,"MUON/Calib/GlobalTriggerBoardMasks"));
 137 }
 138
 139 //_____________________________________________________________________________
 140 TMap*
 141 AliMUONCalibrationData::CreateHV(Int_t runNumber)
 142 {
 143   /// Create a new HV map from the OCDB for a given run
 144   return dynamic_cast<TMap*>(CreateObject(runNumber,"MUON/Calib/HV"));
 145 }
 146
 147 //_____________________________________________________________________________
 148 AliMUONVStore*
 149 AliMUONCalibrationData::CreateLocalTriggerBoardMasks(Int_t runNumber)
 150 {
 151   /// Get the internal store for LocalTriggerBoardMasks from OCDB
 152
 153   return dynamic_cast<AliMUONVStore*>(CreateObject(runNumber,"MUON/Calib/LocalTriggerBoardMasks"));
 154 }
 155
 156 //_____________________________________________________________________________
 157 AliMUONVStore*
 158 AliMUONCalibrationData::CreateNeighbours(Int_t runNumber)
 159 {
 160   /// Create a neighbour store from the OCDB for a given run
 161   return dynamic_cast<AliMUONVStore*>(CreateObject(runNumber,"MUON/Calib/Neighbours"));
 162 }
 163
 164 //_____________________________________________________________________________
 165 TObject*
 166 AliMUONCalibrationData::CreateObject(Int_t runNumber, const char* path)
 167 {
 168   /// Access the CDB for a given path (e.g. MUON/Calib/Pedestals),
 169   /// and return the corresponding TObject.
 170
 171   AliCodeTimerAutoClass(Form("%d : %s",runNumber,path));
 172
 173   AliCDBManager* man = AliCDBManager::Instance();
 174
 175   Bool_t undefStorage(kFALSE);
 176
 177   if ( !man->IsDefaultStorageSet() )
 178   {
 179     TString storage("local://$ALICE_ROOT");
 180     AliInfoClass(Form("CDB Storage not set. Will use %s for MUON stuff",storage.Data()));
 181     man->SetDefaultStorage(storage.Data());
 182     undefStorage = kTRUE;
 183   }
 184
 185   Bool_t cacheStatus = man->GetCacheFlag();
 186
 187   man->SetCacheFlag(kFALSE);
 188
 189   AliCDBEntry* entry =  AliCDBManager::Instance()->Get(path,runNumber);
 190
 191   man->SetCacheFlag(cacheStatus);
 192
 193   if (entry)
 194   {
 195     TObject* object = entry->GetObject();
 196     entry->SetOwner(kFALSE);
 197     delete entry;
 198     return object;
 199   }
 200
 201   if ( undefStorage )
 202   {
 203     man->UnsetDefaultStorage();
 204   }
 205
 206   return 0x0;
 207 }
 208
 209 //_____________________________________________________________________________
 210 AliMUONVStore*
 211 AliMUONCalibrationData::CreatePedestals(Int_t runNumber)
 212 {
 213   /// Create a new pedestal store from the OCDB for a given run
 214   return dynamic_cast<AliMUONVStore*>(CreateObject(runNumber,"MUON/Calib/Pedestals"));
 215 }
 216
 217 //_____________________________________________________________________________
 218 AliMUONVStore*
 219 AliMUONCalibrationData::CreateRegionalTriggerBoardMasks(Int_t runNumber)
 220 {
 221   /// Create the internal store for RegionalTriggerBoardMasks from OCDB
 222
 223   return dynamic_cast<AliMUONVStore*>(CreateObject(runNumber,"MUON/Calib/RegionalTriggerBoardMasks"));
 224 }
 225
 226 //_____________________________________________________________________________
 227 AliMUONTriggerEfficiencyCells*
 228 AliMUONCalibrationData::CreateTriggerEfficiency(Int_t runNumber)
 229 {
 230   /// Create trigger efficiency object from OCBD
 231
 232   return dynamic_cast<AliMUONTriggerEfficiencyCells*>(CreateObject(runNumber,"MUON/Calib/TriggerEfficiency"));
 233 }
 234
 235 //_____________________________________________________________________________
 236 AliMUONTriggerLut*
 237 AliMUONCalibrationData::CreateTriggerLut(Int_t runNumber)
 238 {
 239   /// Create trigger LUT from OCDB
 240
 241   return dynamic_cast<AliMUONTriggerLut*>(CreateObject(runNumber,"MUON/Calib/TriggerLut"));
 242 }
 243
 244 //_____________________________________________________________________________
 245 AliMUONVStore*
 246 AliMUONCalibrationData::Gains() const
 247 {
 248   /// Create (if needed) and return the internal store for gains.
 249   if (!fGains)
 250   {
 251     fGains = CreateGains(fRunNumber);
 252   }
 253   return fGains;
 254 }
 255
 256 //_____________________________________________________________________________
 257 AliMUONVCalibParam*
 258 AliMUONCalibrationData::Gains(Int_t detElemId, Int_t manuId) const
 259 {
 260 /// Return the gains for a given (detElemId, manuId) pair
 261 /// Note that, unlike the DeadChannel case, if the result is 0x0, that's an
 262 /// error (meaning that we should get gains for all channels).
 263
 264   AliMUONVStore* gains = Gains();
 265   if (!gains)
 266   {
 267     return 0x0;
 268   }
 269
 270   return static_cast<AliMUONVCalibParam*>(gains->FindObject(detElemId,manuId));
 271 }
 272
 273 //_____________________________________________________________________________
 274 AliMUONVCalibParam*
 275 AliMUONCalibrationData::GlobalTriggerBoardMasks() const
 276 {
 277   /// Return the masks for the global trigger board.
 278
 279   if (!fGlobalTriggerBoardMasks)
 280   {
 281     fGlobalTriggerBoardMasks = CreateGlobalTriggerBoardMasks(fRunNumber);
 282   }
 283   return fGlobalTriggerBoardMasks;
 284 }
 285
 286 //_____________________________________________________________________________
 287 TMap*
 288 AliMUONCalibrationData::HV() const
 289 {
 290   /// Return the calibration for a given (detElemId, manuId) pair
 291
 292   if (!fHV)
 293   {
 294     fHV = CreateHV(fRunNumber);
 295   }
 296   return fHV;
 297 }
 298
 299 //_____________________________________________________________________________
 300 AliMUONVStore*
 301 AliMUONCalibrationData::Neighbours() const
 302 {
 303   /// Create (if needed) and return the internal store for neighbours.
 304   if (!fNeighbours)
 305   {
 306     fNeighbours = CreateNeighbours(fRunNumber);
 307   }
 308   return fNeighbours;
 309 }
 310
 311 //_____________________________________________________________________________
 312 AliMUONVCalibParam*
 313 AliMUONCalibrationData::LocalTriggerBoardMasks(Int_t localBoardNumber) const
 314 {
 315 /// Return the masks for a given trigger local board.
 316
 317   if (!fLocalTriggerBoardMasks)
 318   {
 319     fLocalTriggerBoardMasks = CreateLocalTriggerBoardMasks(fRunNumber);
 320   }
 321
 322   if ( fLocalTriggerBoardMasks )
 323   {
 324     AliMUONVCalibParam* ltbm =
 325       static_cast<AliMUONVCalibParam*>(fLocalTriggerBoardMasks->FindObject(localBoardNumber));
 326     if (!ltbm)
 327     {
 328       AliError(Form("Could not get mask for localBoardNumber=%d",localBoardNumber));
 329     }
 330     return ltbm;
 331   }
 332   return 0x0;
 333 }
 334
 335 //_____________________________________________________________________________
 336 AliMUONVStore*
 337 AliMUONCalibrationData::Pedestals() const
 338 {
 339   /// Return pedestals
 340   if (!fPedestals)
 341   {
 342     fPedestals = CreatePedestals(fRunNumber);
 343   }
 344   return fPedestals;
 345 }
 346
 347 //_____________________________________________________________________________
 348 AliMUONVCalibParam*
 349 AliMUONCalibrationData::Pedestals(Int_t detElemId, Int_t manuId) const
 350 {
 351   /// Return the pedestals for a given (detElemId, manuId) pair.
 352   /// A return value of 0x0 is considered an error, meaning we should get
 353   /// pedestals for all channels.
 354
 355   AliMUONVStore* pedestals = Pedestals();
 356   if (!pedestals)
 357   {
 358     return 0x0;
 359   }
 360
 361   return static_cast<AliMUONVCalibParam*>(pedestals->FindObject(detElemId,manuId));
 362 }
 363
 364 //_____________________________________________________________________________
 365 void
 366 AliMUONCalibrationData::Print(Option_t*) const
 367 {
 368   /// A very basic dump of our guts.
 369
 370   cout << "RunNumber " << RunNumber()
 371   << " fGains=" << fGains
 372   << " fPedestals=" << fPedestals
 373   << " fHV=" << fHV
 374   << " fLocalTriggerBoardMasks=" << fLocalTriggerBoardMasks
 375   << " fRegionalTriggerBoardMasks=" << fRegionalTriggerBoardMasks
 376   << " fGlobalTriggerBoardMasks=" << fGlobalTriggerBoardMasks
 377   << " fTriggerLut=" << fTriggerLut
 378   << endl;
 379 }
 380
 381 //_____________________________________________________________________________
 382 AliMUONVCalibParam*
 383 AliMUONCalibrationData::RegionalTriggerBoardMasks(Int_t regionalBoardNumber) const
 384 {
 385 /// Return the masks for a given trigger regional board.
 386
 387   if ( !fRegionalTriggerBoardMasks )
 388   {
 389     fRegionalTriggerBoardMasks = CreateRegionalTriggerBoardMasks(fRunNumber);
 390   }
 391
 392   if ( fRegionalTriggerBoardMasks )
 393   {
 394     AliMUONVCalibParam* rtbm =
 395       static_cast<AliMUONVCalibParam*>(fRegionalTriggerBoardMasks->FindObject(regionalBoardNumber));
 396
 397     if (!rtbm)
 398     {
 399       AliError(Form("Could not get mask for regionalBoard index=%d",regionalBoardNumber));
 400     }
 401     return rtbm;
 402   }
 403   return 0x0;
 404 }
 405
 406 //_____________________________________________________________________________
 407 AliMUONTriggerEfficiencyCells*
 408 AliMUONCalibrationData::TriggerEfficiency() const
 409 {
 410 /// Return the trigger efficiency.
 411
 412   if (!fTriggerEfficiency)
 413   {
 414     fTriggerEfficiency = CreateTriggerEfficiency(fRunNumber);
 415   }
 416   return fTriggerEfficiency;
 417 }
 418
 419
 420 //_____________________________________________________________________________
 421 AliMUONTriggerLut*
 422 AliMUONCalibrationData::TriggerLut() const
 423 {
 424 /// Return the trigger look up table.
 425
 426   if (!fTriggerLut)
 427   {
 428     fTriggerLut = CreateTriggerLut(fRunNumber);
 429   }
 430   return fTriggerLut;
 431 }
 432
 433 //_____________________________________________________________________________
 434 void
 435 AliMUONCalibrationData::Reset()
 436 {
 437 /// Reset all data
 438
 439   delete fPedestals;
 440   fPedestals = 0x0;
 441   delete fGains;
 442   fGains = 0x0;
 443   delete fHV;
 444   fHV = 0x0;
 445   delete fLocalTriggerBoardMasks;
 446   fLocalTriggerBoardMasks = 0x0;
 447   delete fRegionalTriggerBoardMasks;
 448   fRegionalTriggerBoardMasks = 0x0;
 449   delete fGlobalTriggerBoardMasks;
 450   fGlobalTriggerBoardMasks = 0x0;
 451   delete fTriggerLut;
 452   fTriggerLut = 0x0;
 453   delete fTriggerEfficiency;
 454   fTriggerEfficiency = 0x0;
 455   delete fCapacitances;
 456   fCapacitances = 0x0;
 457   delete fNeighbours;
 458   fNeighbours = 0x0;
 459 }
 460
 461
 462