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