HLT (temporary?) excluded from processing, as no files are produced by HLT DA for...
[u/mrichter/AliRoot.git] / 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   // and all channels are good (alive)
145
146   fCalibDataEmc     ->Reset();
147   fCalibDataCpv     ->Reset();
148   fEmcBadChannelsMap->Reset();
149 }
150
151 //________________________________________________________________
152 void  AliPHOSCalibData::Print(Option_t *option) const
153 {
154   // Print EMC and CPV calibration containers
155   // Input: option="ped"  to print pedestals
156   //        option="gain" to print calibration coefficients
157   if (fCalibDataEmc) fCalibDataEmc->Print(option);
158   if (fCalibDataCpv) fCalibDataCpv->Print(option);
159 }
160
161 //________________________________________________________________
162 void AliPHOSCalibData::CreateNew()
163 {
164   // Create new EMC and CPV calibration containers with ideal coefficients
165
166   if(fCalibDataEmc) delete fCalibDataEmc;
167   fCalibDataEmc = new AliPHOSEmcCalibData("PHOS-EMC");
168
169   if(fCalibDataCpv) delete fCalibDataCpv;
170   fCalibDataCpv = new AliPHOSCpvCalibData("PHOS-CPV");
171
172   if(fEmcBadChannelsMap) delete fEmcBadChannelsMap;
173   fEmcBadChannelsMap = new AliPHOSEmcBadChannelsMap();
174
175 }
176
177 //________________________________________________________________
178 Bool_t AliPHOSCalibData::WriteEmc(Int_t firstRun, Int_t lastRun, AliCDBMetaData *md)
179 {
180   // Write EMC calibration container to CDB
181
182   if(!fCalibDataEmc) return kFALSE;
183
184   AliCDBStorage* storage = AliCDBManager::Instance()->GetSpecificStorage("PHOS/*");
185   if(!storage)
186     storage = AliCDBManager::Instance()->GetDefaultStorage();
187
188   if(storage) { 
189     AliCDBId id(fEmcDataPath.Data(),firstRun,lastRun);
190     storage->Put(fCalibDataEmc,id, md);
191     return kTRUE;
192   }
193   else
194     return kFALSE;
195
196 }
197
198 //________________________________________________________________
199 Bool_t AliPHOSCalibData::WriteCpv(Int_t firstRun, Int_t lastRun, AliCDBMetaData *md)
200 {
201   // Write CPV calibration container to CDB
202
203   if(!fCalibDataCpv) return kFALSE;
204   
205   AliCDBStorage* storage = AliCDBManager::Instance()->GetSpecificStorage("PHOS/*");
206   if(!storage)
207     storage = AliCDBManager::Instance()->GetDefaultStorage();
208
209   if(storage) { 
210     AliCDBId id(fCpvDataPath.Data(),firstRun,lastRun);
211     storage->Put(fCalibDataCpv,id, md);
212     return kTRUE;
213   }
214   else
215     return kFALSE;
216
217 }
218
219
220 //________________________________________________________________
221 Bool_t AliPHOSCalibData::WriteEmcBadChannelsMap(Int_t firstRun,Int_t lastRun,AliCDBMetaData *md)
222 {
223   //Write EMC bad channels map into CDB.
224
225   if(!fEmcBadChannelsMap) return kFALSE;
226   
227   AliCDBStorage* storage = AliCDBManager::Instance()->GetSpecificStorage("PHOS/*");
228   if(!storage)
229     storage = AliCDBManager::Instance()->GetDefaultStorage();
230
231   if(storage) { 
232     AliCDBId id(fEmcBadChannelsMapPath.Data(),firstRun,lastRun);
233     storage->Put(fEmcBadChannelsMap,id, md);
234     return kTRUE;
235   }
236   else
237     return kFALSE;
238 }
239
240 //________________________________________________________________
241 Float_t AliPHOSCalibData::GetADCchannelEmc(Int_t module, Int_t column, Int_t row) const
242 {
243   // Return EMC calibration coefficient
244   // for channel defined by (module,column,row)
245   // module, column,raw should follow the internal PHOS convention:
246   // module 1:5, column 1:56, row 1:64
247   // if CBD instance exists, the value is taken from CDB.
248   // Otherwise it is an ideal one
249
250   if(fCalibDataEmc) 
251     return fCalibDataEmc->GetADCchannelEmc(module,column,row);
252   else
253     return 1.0; // default width of one EMC ADC channel in GeV
254 }
255
256 //________________________________________________________________
257 void AliPHOSCalibData::SetADCchannelEmc(Int_t module, Int_t column, Int_t row, Float_t value)
258 {
259   // Set EMC calibration coefficient for (module,column,row)
260
261   if(!fCalibDataEmc)
262     fCalibDataEmc = new AliPHOSEmcCalibData("PHOS-EMC");
263
264   fCalibDataEmc->SetADCchannelEmc(module,column,row,value);
265 }
266
267 //________________________________________________________________
268 Float_t AliPHOSCalibData::GetADCpedestalEmc(Int_t module, Int_t column, Int_t row) const
269 {
270   // Return EMC pedestal for channel defined by (module,column,row)
271   // module, column,raw should follow the internal PHOS convention:
272   // module 1:5, column 1:56, row 1:64
273   // if CBD instance exists, the value is taken from CDB.
274   // Otherwise it is an ideal one
275
276   if(fCalibDataEmc) 
277     return fCalibDataEmc->GetADCpedestalEmc(module,column,row);
278   else
279     return 0.0; // default EMC ADC pedestal
280 }
281
282 //________________________________________________________________
283 void AliPHOSCalibData::SetADCpedestalEmc(Int_t module, Int_t column, Int_t row, Float_t value)
284 {
285   // Set EMC pedestal for (module,column,row)
286
287   if(!fCalibDataEmc)
288     fCalibDataEmc = new AliPHOSEmcCalibData("PHOS-EMC");
289
290   fCalibDataEmc->SetADCpedestalEmc(module,column,row,value);
291 }
292
293 //________________________________________________________________
294 Float_t AliPHOSCalibData::GetHighLowRatioEmc(Int_t module, Int_t column, Int_t row) const
295 {
296   // Return EMC calibration coefficient
297   // for channel defined by (module,column,row)
298   // module, column,raw should follow the internal PHOS convention:
299   // module 1:5, column 1:56, row 1:64
300   // if CBD instance exists, the value is taken from CDB.
301   // Otherwise it is an ideal one
302  
303   if(fCalibDataEmc)
304     return fCalibDataEmc->GetHighLowRatioEmc(module,column,row);
305   else
306     return 1.0; // default width of one EMC ADC channel in GeV
307 }
308  
309 //________________________________________________________________
310 void AliPHOSCalibData::SetHighLowRatioEmc(Int_t module, Int_t column, Int_t row, Float_t value)
311 {
312   // Set EMC calibration coefficient for (module,column,row)
313  
314   if(!fCalibDataEmc)
315     fCalibDataEmc = new AliPHOSEmcCalibData("PHOS-EMC");
316  
317   fCalibDataEmc->SetHighLowRatioEmc(module,column,row,value);
318 }
319  
320 //________________________________________________________________
321 Float_t AliPHOSCalibData::GetTimeShiftEmc(Int_t module, Int_t column, Int_t row) const
322
323   // Return EMC calibration coefficient 
324   // for channel defined by (module,column,row)                                
325   // module, column,raw should follow the internal PHOS convention:            
326   // module 1:5, column 1:56, row 1:64 
327   // if CBD instance exists, the value is taken from CDB. 
328   // Otherwise it is an ideal one  
329   
330   if(fCalibDataEmc)
331     return fCalibDataEmc->GetTimeShiftEmc(module,column,row);
332   else
333     return 1.0; // default width of one EMC ADC channel in GeV
334 }
335  
336 //________________________________________________________________
337 void AliPHOSCalibData::SetTimeShiftEmc(Int_t module, Int_t column, Int_t row, Float_t value)
338 {
339   // Set EMC calibration coefficient for (module,column,row)
340  
341   if(!fCalibDataEmc)
342     fCalibDataEmc = new AliPHOSEmcCalibData("PHOS-EMC");
343  
344   fCalibDataEmc->SetTimeShiftEmc(module,column,row,value);
345 }
346 //________________________________________________________________
347 Float_t AliPHOSCalibData::GetSampleTimeStep() const 
348 {
349   //Get conversion coeff. from sample time step to seconds.
350   //Negative value means that it is not used in reconstruction
351   //but only in simulation of raw.
352   if(fCalibDataEmc)
353     return fCalibDataEmc->GetSampleTimeStep();
354   else
355     return 0.0; // default width of one EMC ADC channel in GeV
356 }
357 //________________________________________________________________
358 void   AliPHOSCalibData::SetSampleTimeStep(Float_t step)
359 {
360   //Set conversion coeff. from sample time step to seconds.
361   //Negative value means that it is not used in reconstruction
362   //but only in simulation of raw.
363   if(!fCalibDataEmc)
364     fCalibDataEmc = new AliPHOSEmcCalibData("PHOS-EMC");
365
366   fCalibDataEmc->SetSampleTimeStep(step) ;
367 }
368 //________________________________________________________________
369 Int_t AliPHOSCalibData::GetAltroOffsetEmc(Int_t module, Int_t column, Int_t row) const
370 {
371   // Return ALTRO pedestal coefficient
372   // for channel defined by (module,column,row)
373   // module, column,raw should follow the internal PHOS convention:
374   // module 1:5, column 1:56, row 1:64
375   // if CBD instance exists, the value is taken from CDB.
376   // Otherwise it is an ideal one
377  
378   if(fCalibDataEmc)
379     return fCalibDataEmc->GetAltroOffsetEmc(module,column,row);
380   else
381     return 0; // default width of one EMC ADC channel in GeV
382 }
383  
384 //________________________________________________________________
385 void AliPHOSCalibData::SetAltroOffsetEmc(Int_t module, Int_t column, Int_t row, Int_t value)
386 {
387   // Set altro offset for (module,column,row)
388  
389   if(!fCalibDataEmc)
390     fCalibDataEmc = new AliPHOSEmcCalibData("PHOS-EMC");
391  
392   fCalibDataEmc->SetAltroOffsetEmc(module,column,row,value);
393 }
394
395  
396 //________________________________________________________________
397 Float_t AliPHOSCalibData::GetADCchannelCpv(Int_t module, Int_t column, Int_t row) const
398 {
399   // Return CPV calibration coefficient
400   // for channel defined by (module,column,row)
401   // module, column,raw should follow the internal CPV convention:
402   // module 1:5, column 1:56, row 1:128
403   // if CBD instance exists, the value is taken from CDB.
404   // Otherwise it is an ideal one
405
406   if(fCalibDataCpv) 
407     return fCalibDataCpv->GetADCchannelCpv(module,column,row);
408   else
409     return 0.0012; // default width of one ADC channel in CPV arbitrary units
410 }
411
412 //________________________________________________________________
413 Float_t AliPHOSCalibData::GetADCpedestalCpv(Int_t module, Int_t column, Int_t row) const
414 {
415   // Return CPV pedestal
416   // for channel defined by (module,column,row)
417   // module, column,raw should follow the internal CPV convention:
418   // module 1:5, column 1:56, row 1:128
419   // if CBD instance exists, the value is taken from CDB.
420   // Otherwise it is an ideal one
421
422   if(fCalibDataCpv) 
423     return fCalibDataCpv->GetADCpedestalCpv(module,column,row);
424   else
425     return 0.012; // default CPV ADC pedestal
426 }
427
428 //________________________________________________________________
429 void AliPHOSCalibData::SetADCchannelCpv(Int_t module, Int_t column, Int_t row, Float_t value)
430 {
431   // Set CPV calibration coefficient for (module,column,row)
432
433   if(!fCalibDataCpv)
434     fCalibDataCpv = new AliPHOSCpvCalibData("PHOS-CPV");
435
436   fCalibDataCpv->SetADCchannelCpv(module,column,row,value);
437 }
438
439 //________________________________________________________________
440 void AliPHOSCalibData::SetADCpedestalCpv(Int_t module, Int_t column, Int_t row, Float_t value)
441 {
442   // Set CPV pedestal for (module,column,row)
443
444   if(!fCalibDataCpv)
445     fCalibDataCpv = new AliPHOSCpvCalibData("PHOS-CPV");
446
447   fCalibDataCpv->SetADCpedestalCpv(module,column,row,value);
448 }
449
450 //________________________________________________________________
451 void AliPHOSCalibData::RandomEmc(Float_t ccMin, Float_t ccMax)
452 {
453   // Create decalibrated EMC with calibration coefficients and pedestals
454   // randomly distributed within hard-coded limits
455   // Default spread of calibration parameters is Cmax/Cmin = 4, (Cmax-Cmin)/2 = 1
456
457   if(fCalibDataEmc) delete fCalibDataEmc;
458   fCalibDataEmc = new AliPHOSEmcCalibData("PHOS-EMC");
459
460   TRandom rn;
461   rn.SetSeed(0); //the seed is set to the current  machine clock
462   
463   Float_t adcChannelEmc,adcPedestalEmc;
464
465   for(Int_t module=1; module<6; module++) {
466     for(Int_t column=1; column<57; column++) {
467       for(Int_t row=1; row<65; row++) {
468         adcChannelEmc =rn.Uniform(ccMin,ccMax);
469         adcPedestalEmc=rn.Uniform(0.0,0.0); // 0 spread of pedestals
470         fCalibDataEmc->SetADCchannelEmc(module,column,row,adcChannelEmc);
471         fCalibDataEmc->SetADCpedestalEmc(module,column,row,adcPedestalEmc);
472       }
473     }
474   }
475
476 }
477
478 //________________________________________________________________
479 void AliPHOSCalibData::RandomCpv(Float_t ccMin, Float_t ccMax)
480 {
481   // Create decalibrated CPV with calibration coefficients and pedestals
482   // randomly distributed within hard-coded limits
483   // Default spread of calibration parameters is  0.0012 +- 25%
484
485   if(fCalibDataCpv) delete fCalibDataCpv;
486   fCalibDataCpv = new AliPHOSCpvCalibData("PHOS-CPV");
487
488   TRandom rn;
489   rn.SetSeed(0); //the seed is set to the current  machine clock
490   
491   Float_t adcChannelCpv,adcPedestalCpv;
492
493   for(Int_t module=1; module<6; module++) {
494     for(Int_t column=1; column<57; column++) {
495       for(Int_t row=1; row<129; row++) {
496         adcChannelCpv =rn.Uniform(ccMin,ccMax);
497         adcPedestalCpv=rn.Uniform(0.0048,0.0192); // Ped[max]/Ped[min] = 4, <Ped> = 0.012
498         fCalibDataCpv->SetADCchannelCpv(module,column,row,adcChannelCpv);
499         fCalibDataCpv->SetADCpedestalCpv(module,column,row,adcPedestalCpv);
500       }
501     }
502   }
503 }
504 //________________________________________________________________
505 Bool_t AliPHOSCalibData::IsBadChannelEmc(Int_t module, Int_t col, Int_t row) const
506 {
507   //If no bad channels map found, channel considered good
508
509   if(fEmcBadChannelsMap) 
510     return fEmcBadChannelsMap->IsBadChannel(module,col,row);
511   else
512     return kFALSE;
513 }
514
515 //________________________________________________________________
516 Int_t AliPHOSCalibData::GetNumOfEmcBadChannels() const
517 {
518   if(fEmcBadChannelsMap)
519     return fEmcBadChannelsMap->GetNumOfBadChannels();
520   else
521     return 0;
522 }
523 //________________________________________________________________
524 void AliPHOSCalibData::EmcBadChannelIds(Int_t *badIds)
525 {
526   //Fill array badIds by the Ids of EMC bad channels.
527   //Array badIds of length GetNumOfBadChannels() should be prepared in advance. 
528
529   if(fEmcBadChannelsMap)              
530     fEmcBadChannelsMap->BadChannelIds(badIds);
531 }