PHOS/AliPHOSCalibData.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 for PHOS calibration                                                 //
  21 //                                                                           //
  22 ///////////////////////////////////////////////////////////////////////////////
  23
  24 #include "TRandom.h"
  25 #include "AliLog.h"
  26 #include "AliPHOSCalibData.h"
  27 #include "AliCDBManager.h"
  28 #include "AliCDBStorage.h"
  29 #include "AliCDBId.h"
  30 #include "AliCDBEntry.h"
  31 #include "AliPHOSEmcCalibData.h"
  32 #include "AliPHOSCpvCalibData.h"
  33 #include "AliPHOSEmcBadChannelsMap.h"
  34 #include "AliCDBMetaData.h"
  35
  36 ClassImp(AliPHOSCalibData)
  37
  38 //________________________________________________________________
  39   AliPHOSCalibData::AliPHOSCalibData():
  40     TNamed(),
  41     fCalibDataEmc(0x0),
  42     fCalibDataCpv(0x0),
  43     fEmcBadChannelsMap(0x0),
  44     fEmcDataPath("PHOS/Calib/EmcGainPedestals"),
  45     fCpvDataPath("PHOS/Calib/CpvGainPedestals"),
  46     fEmcBadChannelsMapPath("PHOS/Calib/EmcBadChannels")
  47 {
  48   // Default constructor.
  49   // Open CDB entry, get EMC and CPV calibration data and bad channel map.
  50   // If EMC or CPV calibration data does not exist, stop the run
  51
  52    AliCDBEntry* entryEmc = AliCDBManager::Instance()->Get(fEmcDataPath.Data());
  53   if(entryEmc)
  54     fCalibDataEmc = (AliPHOSEmcCalibData*)entryEmc->GetObject();
  55
  56   if(!fCalibDataEmc)
  57     AliWarning("Calibration parameters for PHOS EMC not found. Create a new set.\n");
  58
  59   AliCDBEntry* entryCpv = AliCDBManager::Instance()->Get(fCpvDataPath.Data());
  60   if(entryCpv)
  61     fCalibDataCpv = (AliPHOSCpvCalibData*)entryCpv->GetObject();
  62
  63   if(!fCalibDataCpv)
  64     AliWarning("Calibration parameters for PHOS CPV not found. Create a new set.\n");
  65
  66   AliCDBEntry* entryEmcBadMap = AliCDBManager::Instance()->Get(fEmcBadChannelsMapPath.Data());
  67   if(entryEmcBadMap)
  68     fEmcBadChannelsMap = (AliPHOSEmcBadChannelsMap*)entryEmcBadMap->GetObject();
  69
  70 }
  71
  72 //________________________________________________________________
  73 AliPHOSCalibData::AliPHOSCalibData(Int_t runNumber) :
  74   TNamed("phosCalib","PHOS Calibration Data Manager"),
  75   fCalibDataEmc(0x0), fCalibDataCpv(0x0), fEmcBadChannelsMap(0x0),
  76   fEmcDataPath("PHOS/Calib/EmcGainPedestals"),
  77   fCpvDataPath("PHOS/Calib/CpvGainPedestals"),
  78   fEmcBadChannelsMapPath("PHOS/Calib/EmcBadChannels")
  79 {
  80   // Constructor
  81   // Open CDB entry, get EMC and CPV calibration data and bad channel map.
  82   // If EMC or CPV calibration data does not exist, stop the run
  83
  84   AliCDBEntry* entryEmc = AliCDBManager::Instance()->Get(fEmcDataPath.Data(),runNumber);
  85   if(entryEmc)
  86     fCalibDataEmc = (AliPHOSEmcCalibData*)entryEmc->GetObject();
  87
  88   if(!fCalibDataEmc)
  89     AliFatal("Calibration parameters for PHOS EMC not found. Stop reconstruction!\n");
  90
  91   AliCDBEntry* entryCpv = AliCDBManager::Instance()->Get(fCpvDataPath.Data(),runNumber);
  92   if(entryCpv)
  93     fCalibDataCpv = (AliPHOSCpvCalibData*)entryCpv->GetObject();
  94
  95   if(!fCalibDataCpv)
  96     AliFatal("Calibration parameters for PHOS CPV not found. Stop reconstruction!\n");
  97
  98   AliCDBEntry* entryEmcBadMap = AliCDBManager::Instance()->
  99     Get(fEmcBadChannelsMapPath.Data(),runNumber);
 100   if(entryEmcBadMap)
 101     fEmcBadChannelsMap = (AliPHOSEmcBadChannelsMap*)entryEmcBadMap->GetObject();
 102
 103 }
 104
 105 //________________________________________________________________
 106 AliPHOSCalibData::AliPHOSCalibData(AliPHOSCalibData & phosCDB) :
 107   TNamed(phosCDB),
 108   fCalibDataEmc(phosCDB.fCalibDataEmc),
 109   fCalibDataCpv(phosCDB.fCalibDataCpv),
 110   fEmcBadChannelsMap(phosCDB.fEmcBadChannelsMap),
 111   fEmcDataPath(phosCDB.fEmcDataPath),
 112   fCpvDataPath(phosCDB.fCpvDataPath),
 113   fEmcBadChannelsMapPath(phosCDB.fEmcBadChannelsMapPath)
 114 {
 115   // Copy constructor
 116 }
 117 //________________________________________________________________
 118 AliPHOSCalibData::~AliPHOSCalibData()
 119 {
 120   // Destructor
 121
 122 }
 123
 124 AliPHOSCalibData & AliPHOSCalibData::operator = (const AliPHOSCalibData & rhs)
 125 {
 126   //Copy-assignment. Does not delete anything (see destructor)
 127   //compiler generated is ok, but ... because -Weffc++ and pointer
 128   //members we have to define it explicitly.
 129   TNamed::operator=(rhs);
 130   fCalibDataEmc = rhs.fCalibDataEmc;
 131   fCalibDataCpv = rhs.fCalibDataCpv;
 132   fEmcBadChannelsMap = rhs.fEmcBadChannelsMap;
 133   fEmcDataPath  = rhs.fEmcDataPath;
 134   fCpvDataPath  = rhs.fCpvDataPath;
 135   fEmcBadChannelsMapPath = rhs.fEmcBadChannelsMapPath;
 136
 137   return *this;
 138 }
 139
 140 //________________________________________________________________
 141 void AliPHOSCalibData::Reset()
 142 {
 143   // Set all pedestals to 0 and all ADC channels to 1
 144
 145   fCalibDataEmc->Reset();
 146   fCalibDataCpv->Reset();
 147 }
 148
 149 //________________________________________________________________
 150 void  AliPHOSCalibData::Print(Option_t *option) const
 151 {
 152   // Print EMC and CPV calibration containers
 153   // Input: option="ped"  to print pedestals
 154   //        option="gain" to print calibration coefficients
 155   if (fCalibDataEmc) fCalibDataEmc->Print(option);
 156   if (fCalibDataCpv) fCalibDataCpv->Print(option);
 157 }
 158
 159 //________________________________________________________________
 160 void AliPHOSCalibData::CreateNew()
 161 {
 162   // Create new EMC and CPV calibration containers with ideal coefficients
 163
 164   if(fCalibDataEmc) delete fCalibDataEmc;
 165   fCalibDataEmc = new AliPHOSEmcCalibData("PHOS-EMC");
 166
 167   if(fCalibDataCpv) delete fCalibDataCpv;
 168   fCalibDataCpv = new AliPHOSCpvCalibData("PHOS-CPV");
 169
 170   if(fEmcBadChannelsMap) delete fEmcBadChannelsMap;
 171   fEmcBadChannelsMap = new AliPHOSEmcBadChannelsMap();
 172
 173 }
 174
 175 //________________________________________________________________
 176 Bool_t AliPHOSCalibData::WriteEmc(Int_t firstRun, Int_t lastRun, AliCDBMetaData *md)
 177 {
 178   // Write EMC calibration container to CDB
 179
 180   if(!fCalibDataEmc) return kFALSE;
 181
 182   AliCDBStorage* storage = AliCDBManager::Instance()->GetSpecificStorage("PHOS/*");
 183   if(!storage)
 184     storage = AliCDBManager::Instance()->GetDefaultStorage();
 185
 186   if(storage) {
 187     AliCDBId id(fEmcDataPath.Data(),firstRun,lastRun);
 188     storage->Put(fCalibDataEmc,id, md);
 189     return kTRUE;
 190   }
 191   else
 192     return kFALSE;
 193
 194 }
 195
 196 //________________________________________________________________
 197 Bool_t AliPHOSCalibData::WriteCpv(Int_t firstRun, Int_t lastRun, AliCDBMetaData *md)
 198 {
 199   // Write CPV calibration container to CDB
 200
 201   if(!fCalibDataCpv) return kFALSE;
 202
 203   AliCDBStorage* storage = AliCDBManager::Instance()->GetSpecificStorage("PHOS/*");
 204   if(!storage)
 205     storage = AliCDBManager::Instance()->GetDefaultStorage();
 206
 207   if(storage) {
 208     AliCDBId id(fCpvDataPath.Data(),firstRun,lastRun);
 209     storage->Put(fCalibDataCpv,id, md);
 210     return kTRUE;
 211   }
 212   else
 213     return kFALSE;
 214
 215 }
 216
 217
 218 //________________________________________________________________
 219 Bool_t AliPHOSCalibData::WriteEmcBadChannelsMap(Int_t firstRun,Int_t lastRun,AliCDBMetaData *md)
 220 {
 221   //Write EMC bad channels map into CDB.
 222
 223   if(!fEmcBadChannelsMap) return kFALSE;
 224
 225   AliCDBStorage* storage = AliCDBManager::Instance()->GetSpecificStorage("PHOS/*");
 226   if(!storage)
 227     storage = AliCDBManager::Instance()->GetDefaultStorage();
 228
 229   if(storage) {
 230     AliCDBId id(fEmcBadChannelsMapPath.Data(),firstRun,lastRun);
 231     storage->Put(fEmcBadChannelsMap,id, md);
 232     return kTRUE;
 233   }
 234   else
 235     return kFALSE;
 236 }
 237
 238 //________________________________________________________________
 239 Float_t AliPHOSCalibData::GetADCchannelEmc(Int_t module, Int_t column, Int_t row) const
 240 {
 241   // Return EMC calibration coefficient
 242   // for channel defined by (module,column,row)
 243   // module, column,raw should follow the internal PHOS convention:
 244   // module 1:5, column 1:56, row 1:64
 245   // if CBD instance exists, the value is taken from CDB.
 246   // Otherwise it is an ideal one
 247
 248   if(fCalibDataEmc)
 249     return fCalibDataEmc->GetADCchannelEmc(module,column,row);
 250   else
 251     return 1.0; // default width of one EMC ADC channel in GeV
 252 }
 253
 254 //________________________________________________________________
 255 Float_t AliPHOSCalibData::GetADCpedestalEmc(Int_t module, Int_t column, Int_t row) const
 256 {
 257   // Return EMC pedestal for channel defined by (module,column,row)
 258   // module, column,raw should follow the internal PHOS convention:
 259   // module 1:5, column 1:56, row 1:64
 260   // if CBD instance exists, the value is taken from CDB.
 261   // Otherwise it is an ideal one
 262
 263   if(fCalibDataEmc)
 264     return fCalibDataEmc->GetADCpedestalEmc(module,column,row);
 265   else
 266     return 0.0; // default EMC ADC pedestal
 267 }
 268
 269 //________________________________________________________________
 270 void AliPHOSCalibData::SetADCchannelEmc(Int_t module, Int_t column, Int_t row, Float_t value)
 271 {
 272   // Set EMC calibration coefficient for (module,column,row)
 273
 274   if(!fCalibDataEmc)
 275     fCalibDataEmc = new AliPHOSEmcCalibData("PHOS-EMC");
 276
 277   fCalibDataEmc->SetADCchannelEmc(module,column,row,value);
 278 }
 279
 280 //________________________________________________________________
 281 void AliPHOSCalibData::SetADCpedestalEmc(Int_t module, Int_t column, Int_t row, Float_t value)
 282 {
 283   // Set EMC pedestal for (module,column,row)
 284
 285   if(!fCalibDataEmc)
 286     fCalibDataEmc = new AliPHOSEmcCalibData("PHOS-EMC");
 287
 288   fCalibDataEmc->SetADCpedestalEmc(module,column,row,value);
 289 }
 290
 291 //________________________________________________________________
 292 Float_t AliPHOSCalibData::GetADCchannelCpv(Int_t module, Int_t column, Int_t row) const
 293 {
 294   // Return CPV calibration coefficient
 295   // for channel defined by (module,column,row)
 296   // module, column,raw should follow the internal CPV convention:
 297   // module 1:5, column 1:56, row 1:128
 298   // if CBD instance exists, the value is taken from CDB.
 299   // Otherwise it is an ideal one
 300
 301   if(fCalibDataCpv)
 302     return fCalibDataCpv->GetADCchannelCpv(module,column,row);
 303   else
 304     return 0.0012; // default width of one ADC channel in CPV arbitrary units
 305 }
 306
 307 //________________________________________________________________
 308 Float_t AliPHOSCalibData::GetADCpedestalCpv(Int_t module, Int_t column, Int_t row) const
 309 {
 310   // Return CPV pedestal
 311   // for channel defined by (module,column,row)
 312   // module, column,raw should follow the internal CPV convention:
 313   // module 1:5, column 1:56, row 1:128
 314   // if CBD instance exists, the value is taken from CDB.
 315   // Otherwise it is an ideal one
 316
 317   if(fCalibDataCpv)
 318     return fCalibDataCpv->GetADCpedestalCpv(module,column,row);
 319   else
 320     return 0.012; // default CPV ADC pedestal
 321 }
 322
 323 //________________________________________________________________
 324 void AliPHOSCalibData::SetADCchannelCpv(Int_t module, Int_t column, Int_t row, Float_t value)
 325 {
 326   // Set CPV calibration coefficient for (module,column,row)
 327
 328   if(!fCalibDataCpv)
 329     fCalibDataCpv = new AliPHOSCpvCalibData("PHOS-CPV");
 330
 331   fCalibDataCpv->SetADCchannelCpv(module,column,row,value);
 332 }
 333
 334 //________________________________________________________________
 335 void AliPHOSCalibData::SetADCpedestalCpv(Int_t module, Int_t column, Int_t row, Float_t value)
 336 {
 337   // Set CPV pedestal for (module,column,row)
 338
 339   if(!fCalibDataCpv)
 340     fCalibDataCpv = new AliPHOSCpvCalibData("PHOS-CPV");
 341
 342   fCalibDataCpv->SetADCpedestalCpv(module,column,row,value);
 343 }
 344
 345 //________________________________________________________________
 346 void AliPHOSCalibData::RandomEmc(Float_t ccMin, Float_t ccMax)
 347 {
 348   // Create decalibrated EMC with calibration coefficients and pedestals
 349   // randomly distributed within hard-coded limits
 350   // Default spread of calibration parameters is Cmax/Cmin = 4, (Cmax-Cmin)/2 = 1
 351
 352   if(fCalibDataEmc) delete fCalibDataEmc;
 353   fCalibDataEmc = new AliPHOSEmcCalibData("PHOS-EMC");
 354
 355   TRandom rn;
 356   rn.SetSeed(0); //the seed is set to the current  machine clock
 357
 358   Float_t adcChannelEmc,adcPedestalEmc;
 359
 360   for(Int_t module=1; module<6; module++) {
 361     for(Int_t column=1; column<57; column++) {
 362       for(Int_t row=1; row<65; row++) {
 363         adcChannelEmc =rn.Uniform(ccMin,ccMax);
 364         adcPedestalEmc=rn.Uniform(0.0,0.0); // 0 spread of pedestals
 365         fCalibDataEmc->SetADCchannelEmc(module,column,row,adcChannelEmc);
 366         fCalibDataEmc->SetADCpedestalEmc(module,column,row,adcPedestalEmc);
 367       }
 368     }
 369   }
 370
 371 }
 372
 373 //________________________________________________________________
 374 void AliPHOSCalibData::RandomCpv(Float_t ccMin, Float_t ccMax)
 375 {
 376   // Create decalibrated CPV with calibration coefficients and pedestals
 377   // randomly distributed within hard-coded limits
 378   // Default spread of calibration parameters is  0.0012 +- 25%
 379
 380   if(fCalibDataCpv) delete fCalibDataCpv;
 381   fCalibDataCpv = new AliPHOSCpvCalibData("PHOS-CPV");
 382
 383   TRandom rn;
 384   rn.SetSeed(0); //the seed is set to the current  machine clock
 385
 386   Float_t adcChannelCpv,adcPedestalCpv;
 387
 388   for(Int_t module=1; module<6; module++) {
 389     for(Int_t column=1; column<57; column++) {
 390       for(Int_t row=1; row<129; row++) {
 391         adcChannelCpv =rn.Uniform(ccMin,ccMax);
 392         adcPedestalCpv=rn.Uniform(0.0048,0.0192); // Ped[max]/Ped[min] = 4, <Ped> = 0.012
 393         fCalibDataCpv->SetADCchannelCpv(module,column,row,adcChannelCpv);
 394         fCalibDataCpv->SetADCpedestalCpv(module,column,row,adcPedestalCpv);
 395       }
 396     }
 397   }
 398 }
 399
 400 //________________________________________________________________
 401 Bool_t AliPHOSCalibData::IsBadChannelEmc(Int_t module, Int_t col, Int_t row) const
 402 {
 403   //If no bad channels map found, channel considered good
 404
 405   if(fEmcBadChannelsMap)
 406     return fEmcBadChannelsMap->IsBadChannel(module,col,row);
 407   else
 408     return kFALSE;
 409 }
 410
 411 //________________________________________________________________
 412 Int_t AliPHOSCalibData::GetNumOfEmcBadChannels() const
 413 {
 414   if(fEmcBadChannelsMap)
 415     return fEmcBadChannelsMap->GetNumOfBadChannels();
 416   else
 417     return 0;
 418 }
 419
 420 //________________________________________________________________
 421 void AliPHOSCalibData::EmcBadChannelIds(Int_t *badIds)
 422 {
 423   //Fill array badIds by the Ids of EMC bad channels.
 424   //Array badIds of length GetNumOfBadChannels() should be prepared in advance.
 425
 426   if(fEmcBadChannelsMap)
 427     fEmcBadChannelsMap->BadChannelIds(badIds);
 428 }