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 }
  53
  54 //________________________________________________________________
  55 AliPHOSCalibData::AliPHOSCalibData(Int_t runNumber) :
  56   TNamed("phosCalib","PHOS Calibration Data Manager"),
  57   fCalibDataEmc(0x0), fCalibDataCpv(0x0), fEmcBadChannelsMap(0x0),
  58   fEmcDataPath("PHOS/Calib/EmcGainPedestals"),
  59   fCpvDataPath("PHOS/Calib/CpvGainPedestals"),
  60   fEmcBadChannelsMapPath("PHOS/Calib/EmcBadChannels")
  61 {
  62   // Constructor
  63   // Open CDB entry, get EMC and CPV calibration data and bad channel map.
  64   // If EMC or CPV calibration data does not exist, stop the run
  65
  66   AliCDBEntry* entryEmc = AliCDBManager::Instance()->Get(fEmcDataPath.Data(),runNumber);
  67   if(entryEmc)
  68     fCalibDataEmc = (AliPHOSEmcCalibData*)entryEmc->GetObject();
  69
  70   if(!fCalibDataEmc)
  71     AliFatal("Calibration parameters for PHOS EMC not found. Stop reconstruction!\n");
  72
  73   AliCDBEntry* entryCpv = AliCDBManager::Instance()->Get(fCpvDataPath.Data(),runNumber);
  74   if(entryCpv)
  75     fCalibDataCpv = (AliPHOSCpvCalibData*)entryCpv->GetObject();
  76
  77   if(!fCalibDataCpv)
  78     AliFatal("Calibration parameters for PHOS CPV not found. Stop reconstruction!\n");
  79
  80   AliCDBEntry* entryEmcBadMap = AliCDBManager::Instance()->
  81     Get(fEmcBadChannelsMapPath.Data(),runNumber);
  82   if(entryEmcBadMap)
  83     fEmcBadChannelsMap = (AliPHOSEmcBadChannelsMap*)entryEmcBadMap->GetObject();
  84
  85 }
  86
  87 //________________________________________________________________
  88 AliPHOSCalibData::AliPHOSCalibData(AliPHOSCalibData & phosCDB) :
  89   TNamed(phosCDB),
  90   fCalibDataEmc(phosCDB.fCalibDataEmc),
  91   fCalibDataCpv(phosCDB.fCalibDataCpv),
  92   fEmcBadChannelsMap(phosCDB.fEmcBadChannelsMap),
  93   fEmcDataPath(phosCDB.fEmcDataPath),
  94   fCpvDataPath(phosCDB.fCpvDataPath),
  95   fEmcBadChannelsMapPath(phosCDB.fEmcBadChannelsMapPath)
  96 {
  97   // Copy constructor
  98 }
  99 //________________________________________________________________
 100 AliPHOSCalibData::~AliPHOSCalibData()
 101 {
 102   // Destructor
 103
 104 }
 105
 106 AliPHOSCalibData & AliPHOSCalibData::operator = (const AliPHOSCalibData & rhs)
 107 {
 108   //Copy-assignment. Does not delete anything (see destructor)
 109   //compiler generated is ok, but ... because -Weffc++ and pointer
 110   //members we have to define it explicitly.
 111   TNamed::operator=(rhs);
 112   fCalibDataEmc = rhs.fCalibDataEmc;
 113   fCalibDataCpv = rhs.fCalibDataCpv;
 114   fEmcBadChannelsMap = rhs.fEmcBadChannelsMap;
 115   fEmcDataPath  = rhs.fEmcDataPath;
 116   fCpvDataPath  = rhs.fCpvDataPath;
 117   fEmcBadChannelsMapPath = rhs.fEmcBadChannelsMapPath;
 118
 119   return *this;
 120 }
 121
 122 //________________________________________________________________
 123 void AliPHOSCalibData::Reset()
 124 {
 125   // Set all pedestals to 0 and all ADC channels to 1,
 126   // and all channels are good (alive)
 127
 128   fCalibDataEmc     ->Reset();
 129   fCalibDataCpv     ->Reset();
 130   fEmcBadChannelsMap->Reset();
 131 }
 132
 133 //________________________________________________________________
 134 void  AliPHOSCalibData::Print(Option_t *option) const
 135 {
 136   // Print EMC and CPV calibration containers
 137   // Input: option="ped"  to print pedestals
 138   //        option="gain" to print calibration coefficients
 139   if (fCalibDataEmc) fCalibDataEmc->Print(option);
 140   if (fCalibDataCpv) fCalibDataCpv->Print(option);
 141 }
 142
 143 //________________________________________________________________
 144 void AliPHOSCalibData::CreateNew()
 145 {
 146   // Create new EMC and CPV calibration containers with ideal coefficients
 147
 148   if(fCalibDataEmc) delete fCalibDataEmc;
 149   fCalibDataEmc = new AliPHOSEmcCalibData("PHOS-EMC");
 150
 151   if(fCalibDataCpv) delete fCalibDataCpv;
 152   fCalibDataCpv = new AliPHOSCpvCalibData("PHOS-CPV");
 153
 154   if(fEmcBadChannelsMap) delete fEmcBadChannelsMap;
 155   fEmcBadChannelsMap = new AliPHOSEmcBadChannelsMap();
 156
 157 }
 158
 159 //________________________________________________________________
 160 Bool_t AliPHOSCalibData::WriteEmc(Int_t firstRun, Int_t lastRun, AliCDBMetaData *md)
 161 {
 162   // Write EMC calibration container to CDB
 163
 164   if(!fCalibDataEmc) return kFALSE;
 165
 166   AliCDBStorage* storage = AliCDBManager::Instance()->GetSpecificStorage("PHOS/*");
 167   if(!storage)
 168     storage = AliCDBManager::Instance()->GetDefaultStorage();
 169
 170   if(storage) {
 171     AliCDBId id(fEmcDataPath.Data(),firstRun,lastRun);
 172     storage->Put(fCalibDataEmc,id, md);
 173     return kTRUE;
 174   }
 175   else
 176     return kFALSE;
 177
 178 }
 179
 180 //________________________________________________________________
 181 Bool_t AliPHOSCalibData::WriteCpv(Int_t firstRun, Int_t lastRun, AliCDBMetaData *md)
 182 {
 183   // Write CPV calibration container to CDB
 184
 185   if(!fCalibDataCpv) return kFALSE;
 186
 187   AliCDBStorage* storage = AliCDBManager::Instance()->GetSpecificStorage("PHOS/*");
 188   if(!storage)
 189     storage = AliCDBManager::Instance()->GetDefaultStorage();
 190
 191   if(storage) {
 192     AliCDBId id(fCpvDataPath.Data(),firstRun,lastRun);
 193     storage->Put(fCalibDataCpv,id, md);
 194     return kTRUE;
 195   }
 196   else
 197     return kFALSE;
 198
 199 }
 200
 201
 202 //________________________________________________________________
 203 Bool_t AliPHOSCalibData::WriteEmcBadChannelsMap(Int_t firstRun,Int_t lastRun,AliCDBMetaData *md)
 204 {
 205   //Write EMC bad channels map into CDB.
 206
 207   if(!fEmcBadChannelsMap) return kFALSE;
 208
 209   AliCDBStorage* storage = AliCDBManager::Instance()->GetSpecificStorage("PHOS/*");
 210   if(!storage)
 211     storage = AliCDBManager::Instance()->GetDefaultStorage();
 212
 213   if(storage) {
 214     AliCDBId id(fEmcBadChannelsMapPath.Data(),firstRun,lastRun);
 215     storage->Put(fEmcBadChannelsMap,id, md);
 216     return kTRUE;
 217   }
 218   else
 219     return kFALSE;
 220 }
 221
 222 //________________________________________________________________
 223 Float_t AliPHOSCalibData::GetADCchannelEmc(Int_t module, Int_t column, Int_t row) const
 224 {
 225   // Return EMC calibration coefficient
 226   // for channel defined by (module,column,row)
 227   // module, column,raw should follow the internal PHOS convention:
 228   // module 1:5, column 1:56, row 1:64
 229   // if CBD instance exists, the value is taken from CDB.
 230   // Otherwise it is an ideal one
 231
 232   if(fCalibDataEmc)
 233     return fCalibDataEmc->GetADCchannelEmc(module,column,row);
 234   else
 235     return 1.0; // default width of one EMC ADC channel in GeV
 236 }
 237
 238 //________________________________________________________________
 239 void AliPHOSCalibData::SetADCchannelEmc(Int_t module, Int_t column, Int_t row, Float_t value)
 240 {
 241   // Set EMC calibration coefficient for (module,column,row)
 242
 243   if(!fCalibDataEmc)
 244     fCalibDataEmc = new AliPHOSEmcCalibData("PHOS-EMC");
 245
 246   fCalibDataEmc->SetADCchannelEmc(module,column,row,value);
 247 }
 248
 249 //________________________________________________________________
 250 Float_t AliPHOSCalibData::GetADCpedestalEmc(Int_t module, Int_t column, Int_t row) const
 251 {
 252   // Return EMC pedestal for channel defined by (module,column,row)
 253   // module, column,raw should follow the internal PHOS convention:
 254   // module 1:5, column 1:56, row 1:64
 255   // if CBD instance exists, the value is taken from CDB.
 256   // Otherwise it is an ideal one
 257
 258   if(fCalibDataEmc)
 259     return fCalibDataEmc->GetADCpedestalEmc(module,column,row);
 260   else
 261     return 0.0; // default EMC ADC pedestal
 262 }
 263
 264 //________________________________________________________________
 265 void AliPHOSCalibData::SetADCpedestalEmc(Int_t module, Int_t column, Int_t row, Float_t value)
 266 {
 267   // Set EMC pedestal for (module,column,row)
 268
 269   if(!fCalibDataEmc)
 270     fCalibDataEmc = new AliPHOSEmcCalibData("PHOS-EMC");
 271
 272   fCalibDataEmc->SetADCpedestalEmc(module,column,row,value);
 273 }
 274
 275 //________________________________________________________________
 276 Float_t AliPHOSCalibData::GetHighLowRatioEmc(Int_t module, Int_t column, Int_t row) const
 277 {
 278   // Return EMC calibration coefficient
 279   // for channel defined by (module,column,row)
 280   // module, column,raw should follow the internal PHOS convention:
 281   // module 1:5, column 1:56, row 1:64
 282   // if CBD instance exists, the value is taken from CDB.
 283   // Otherwise it is an ideal one
 284
 285   if(fCalibDataEmc)
 286     return fCalibDataEmc->GetHighLowRatioEmc(module,column,row);
 287   else
 288     return 1.0; // default width of one EMC ADC channel in GeV
 289 }
 290
 291 //________________________________________________________________
 292 void AliPHOSCalibData::SetHighLowRatioEmc(Int_t module, Int_t column, Int_t row, Float_t value)
 293 {
 294   // Set EMC calibration coefficient for (module,column,row)
 295
 296   if(!fCalibDataEmc)
 297     fCalibDataEmc = new AliPHOSEmcCalibData("PHOS-EMC");
 298
 299   fCalibDataEmc->SetHighLowRatioEmc(module,column,row,value);
 300 }
 301
 302 //________________________________________________________________
 303 Float_t AliPHOSCalibData::GetTimeShiftEmc(Int_t module, Int_t column, Int_t row) const
 304 {
 305   // Return EMC calibration coefficient
 306   // for channel defined by (module,column,row)
 307   // module, column,raw should follow the internal PHOS convention:
 308   // module 1:5, column 1:56, row 1:64
 309   // if CBD instance exists, the value is taken from CDB.
 310   // Otherwise it is an ideal one
 311
 312   if(fCalibDataEmc)
 313     return fCalibDataEmc->GetTimeShiftEmc(module,column,row);
 314   else
 315     return 1.0; // default width of one EMC ADC channel in GeV
 316 }
 317
 318 //________________________________________________________________
 319 void AliPHOSCalibData::SetTimeShiftEmc(Int_t module, Int_t column, Int_t row, Float_t value)
 320 {
 321   // Set EMC calibration coefficient for (module,column,row)
 322
 323   if(!fCalibDataEmc)
 324     fCalibDataEmc = new AliPHOSEmcCalibData("PHOS-EMC");
 325
 326   fCalibDataEmc->SetTimeShiftEmc(module,column,row,value);
 327 }
 328 //________________________________________________________________
 329 Float_t AliPHOSCalibData::GetSampleTimeStep() const
 330 {
 331   //Get conversion coeff. from sample time step to seconds.
 332   //Negative value means that it is not used in reconstruction
 333   //but only in simulation of raw.
 334   if(fCalibDataEmc)
 335     return fCalibDataEmc->GetSampleTimeStep();
 336   else
 337     return 0.0; // default width of one EMC ADC channel in GeV
 338 }
 339 //________________________________________________________________
 340 void   AliPHOSCalibData::SetSampleTimeStep(Float_t step)
 341 {
 342   //Set conversion coeff. from sample time step to seconds.
 343   //Negative value means that it is not used in reconstruction
 344   //but only in simulation of raw.
 345   if(!fCalibDataEmc)
 346     fCalibDataEmc = new AliPHOSEmcCalibData("PHOS-EMC");
 347
 348   fCalibDataEmc->SetSampleTimeStep(step) ;
 349 }
 350 //________________________________________________________________
 351 Int_t AliPHOSCalibData::GetAltroOffsetEmc(Int_t module, Int_t column, Int_t row) const
 352 {
 353   // Return ALTRO pedestal coefficient
 354   // for channel defined by (module,column,row)
 355   // module, column,raw should follow the internal PHOS convention:
 356   // module 1:5, column 1:56, row 1:64
 357   // if CBD instance exists, the value is taken from CDB.
 358   // Otherwise it is an ideal one
 359
 360   if(fCalibDataEmc)
 361     return fCalibDataEmc->GetAltroOffsetEmc(module,column,row);
 362   else
 363     return 0; // default width of one EMC ADC channel in GeV
 364 }
 365
 366 //________________________________________________________________
 367 void AliPHOSCalibData::SetAltroOffsetEmc(Int_t module, Int_t column, Int_t row, Int_t value)
 368 {
 369   // Set altro offset for (module,column,row)
 370
 371   if(!fCalibDataEmc)
 372     fCalibDataEmc = new AliPHOSEmcCalibData("PHOS-EMC");
 373
 374   fCalibDataEmc->SetAltroOffsetEmc(module,column,row,value);
 375 }
 376
 377
 378 //________________________________________________________________
 379 Float_t AliPHOSCalibData::GetADCchannelCpv(Int_t module, Int_t column, Int_t row) const
 380 {
 381   // Return CPV calibration coefficient
 382   // for channel defined by (module,column,row)
 383   // module, column,raw should follow the internal CPV convention:
 384   // module 1:5, column 1:56, row 1:128
 385   // if CBD instance exists, the value is taken from CDB.
 386   // Otherwise it is an ideal one
 387
 388   if(fCalibDataCpv)
 389     return fCalibDataCpv->GetADCchannelCpv(module,column,row);
 390   else
 391     return 0.0012; // default width of one ADC channel in CPV arbitrary units
 392 }
 393
 394 //________________________________________________________________
 395 Float_t AliPHOSCalibData::GetADCpedestalCpv(Int_t module, Int_t column, Int_t row) const
 396 {
 397   // Return CPV pedestal
 398   // for channel defined by (module,column,row)
 399   // module, column,raw should follow the internal CPV convention:
 400   // module 1:5, column 1:56, row 1:128
 401   // if CBD instance exists, the value is taken from CDB.
 402   // Otherwise it is an ideal one
 403
 404   if(fCalibDataCpv)
 405     return fCalibDataCpv->GetADCpedestalCpv(module,column,row);
 406   else
 407     return 0.012; // default CPV ADC pedestal
 408 }
 409
 410 //________________________________________________________________
 411 void AliPHOSCalibData::SetADCchannelCpv(Int_t module, Int_t column, Int_t row, Float_t value)
 412 {
 413   // Set CPV calibration coefficient for (module,column,row)
 414
 415   if(!fCalibDataCpv)
 416     fCalibDataCpv = new AliPHOSCpvCalibData("PHOS-CPV");
 417
 418   fCalibDataCpv->SetADCchannelCpv(module,column,row,value);
 419 }
 420
 421 //________________________________________________________________
 422 void AliPHOSCalibData::SetADCpedestalCpv(Int_t module, Int_t column, Int_t row, Float_t value)
 423 {
 424   // Set CPV pedestal for (module,column,row)
 425
 426   if(!fCalibDataCpv)
 427     fCalibDataCpv = new AliPHOSCpvCalibData("PHOS-CPV");
 428
 429   fCalibDataCpv->SetADCpedestalCpv(module,column,row,value);
 430 }
 431
 432 //________________________________________________________________
 433 void AliPHOSCalibData::RandomEmc(Float_t ccMin, Float_t ccMax)
 434 {
 435   // Create decalibrated EMC with calibration coefficients and pedestals
 436   // randomly distributed within hard-coded limits
 437   // Default spread of calibration parameters is Cmax/Cmin = 4, (Cmax-Cmin)/2 = 1
 438
 439   if(fCalibDataEmc) delete fCalibDataEmc;
 440   fCalibDataEmc = new AliPHOSEmcCalibData("PHOS-EMC");
 441
 442   TRandom rn;
 443   rn.SetSeed(0); //the seed is set to the current  machine clock
 444
 445   Float_t adcChannelEmc,adcPedestalEmc;
 446
 447   for(Int_t module=1; module<6; module++) {
 448     for(Int_t column=1; column<57; column++) {
 449       for(Int_t row=1; row<65; row++) {
 450         adcChannelEmc =rn.Uniform(ccMin,ccMax);
 451         adcPedestalEmc=rn.Uniform(0.0,0.0); // 0 spread of pedestals
 452         fCalibDataEmc->SetADCchannelEmc(module,column,row,adcChannelEmc);
 453         fCalibDataEmc->SetADCpedestalEmc(module,column,row,adcPedestalEmc);
 454       }
 455     }
 456   }
 457
 458 }
 459
 460 //________________________________________________________________
 461 void AliPHOSCalibData::RandomCpv(Float_t ccMin, Float_t ccMax)
 462 {
 463   // Create decalibrated CPV with calibration coefficients and pedestals
 464   // randomly distributed within hard-coded limits
 465   // Default spread of calibration parameters is  0.0012 +- 25%
 466
 467   if(fCalibDataCpv) delete fCalibDataCpv;
 468   fCalibDataCpv = new AliPHOSCpvCalibData("PHOS-CPV");
 469
 470   TRandom rn;
 471   rn.SetSeed(0); //the seed is set to the current  machine clock
 472
 473   Float_t adcChannelCpv,adcPedestalCpv;
 474
 475   for(Int_t module=1; module<6; module++) {
 476     for(Int_t column=1; column<57; column++) {
 477       for(Int_t row=1; row<129; row++) {
 478         adcChannelCpv =rn.Uniform(ccMin,ccMax);
 479         adcPedestalCpv=rn.Uniform(0.0048,0.0192); // Ped[max]/Ped[min] = 4, <Ped> = 0.012
 480         fCalibDataCpv->SetADCchannelCpv(module,column,row,adcChannelCpv);
 481         fCalibDataCpv->SetADCpedestalCpv(module,column,row,adcPedestalCpv);
 482       }
 483     }
 484   }
 485 }
 486 //________________________________________________________________
 487 Bool_t AliPHOSCalibData::IsBadChannelEmc(Int_t module, Int_t col, Int_t row) const
 488 {
 489   //If no bad channels map found, channel considered good
 490
 491   if(fEmcBadChannelsMap)
 492     return fEmcBadChannelsMap->IsBadChannel(module,col,row);
 493   else
 494     return kFALSE;
 495 }
 496
 497 //________________________________________________________________
 498 Int_t AliPHOSCalibData::GetNumOfEmcBadChannels() const
 499 {
 500   if(fEmcBadChannelsMap)
 501     return fEmcBadChannelsMap->GetNumOfBadChannels();
 502   else
 503     return 0;
 504 }
 505 //________________________________________________________________
 506 void AliPHOSCalibData::EmcBadChannelIds(Int_t *badIds)
 507 {
 508   //Fill array badIds by the Ids of EMC bad channels.
 509   //Array badIds of length GetNumOfBadChannels() should be prepared in advance.
 510
 511   if(fEmcBadChannelsMap)
 512     fEmcBadChannelsMap->BadChannelIds(badIds);
 513 }
 514
 515 //________________________________________________________________
 516 Float_t AliPHOSCalibData::GetADCchannelEmcDecalib(Int_t module, Int_t column, Int_t row) const
 517 {
 518   // Return random EMC (de)calibration factor O(1) for channel defined by (module,column,row).
 519   // Used in simulation.
 520
 521   // module, column,raw should follow the internal PHOS convention:
 522   // module 1:5, column 1:56, row 1:64
 523   // if CBD instance exists, the value is taken from CDB.
 524   // Otherwise it is an ideal one (no decalibration).
 525
 526   if(fCalibDataEmc)
 527     return fCalibDataEmc->GetADCchannelEmcDecalib(module,column,row);
 528   else
 529     return 1.0; // no decalibration by default
 530 }
 531
 532 //________________________________________________________________
 533 void AliPHOSCalibData::SetADCchannelEmcDecalib(Int_t module, Int_t column, Int_t row, Float_t value)
 534 {
 535   // Set EMC (de)calibration factor for (module,column,row).
 536   // Used in simulation.
 537
 538   if(!fCalibDataEmc)
 539     fCalibDataEmc = new AliPHOSEmcCalibData("PHOS-EMC");
 540
 541   fCalibDataEmc->SetADCchannelEmcDecalib(module,column,row,value);
 542 }