EMC bad channels map added.
[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 "AliPHOSCalibData.h"
26 #include "AliCDBManager.h"
27 #include "AliCDBStorage.h"
28 #include "AliCDBId.h"
29 #include "AliCDBEntry.h"
30 #include "AliPHOSEmcCalibData.h"
31 #include "AliPHOSCpvCalibData.h"
32 #include "AliPHOSEmcBadChannelsMap.h"
33 #include "AliCDBMetaData.h"
34
35 ClassImp(AliPHOSCalibData)
36
37 //________________________________________________________________
38   AliPHOSCalibData::AliPHOSCalibData(): 
39     TNamed(), 
40     fCalibDataEmc(0x0), 
41     fCalibDataCpv(0x0),
42     fEmcBadChannelsMap(0x0),
43     fEmcDataPath("PHOS/Calib/EmcGainPedestals"),
44     fCpvDataPath("PHOS/Calib/CpvGainPedestals"),
45     fEmcBadChannelsMapPath("PHOS/Calib/EmcBadChannels")
46 {
47   // Default constructor
48   
49    AliCDBEntry* entryEmc = AliCDBManager::Instance()->Get(fEmcDataPath.Data());
50   if(entryEmc)
51     fCalibDataEmc = (AliPHOSEmcCalibData*)entryEmc->GetObject();
52   
53   AliCDBEntry* entryCpv = AliCDBManager::Instance()->Get(fCpvDataPath.Data());
54   if(entryCpv)
55     fCalibDataCpv = (AliPHOSCpvCalibData*)entryCpv->GetObject();
56
57   AliCDBEntry* entryEmcBadMap = AliCDBManager::Instance()->Get(fEmcBadChannelsMapPath.Data());
58   if(entryEmcBadMap)
59     fEmcBadChannelsMap = (AliPHOSEmcBadChannelsMap*)entryEmcBadMap->GetObject(); 
60
61 }
62
63 //________________________________________________________________
64 AliPHOSCalibData::AliPHOSCalibData(Int_t runNumber) :
65   TNamed("phosCalib","PHOS Calibration Data Manager"),
66   fCalibDataEmc(0x0), fCalibDataCpv(0x0), fEmcBadChannelsMap(0x0),
67   fEmcDataPath("PHOS/Calib/EmcGainPedestals"),
68   fCpvDataPath("PHOS/Calib/CpvGainPedestals"),
69   fEmcBadChannelsMapPath("PHOS/Calib/EmcBadChannels")
70 {
71   // Constructor
72   AliCDBEntry* entryEmc = AliCDBManager::Instance()->Get(fEmcDataPath.Data(),runNumber);
73   if(entryEmc)
74     fCalibDataEmc = (AliPHOSEmcCalibData*)entryEmc->GetObject();
75   
76   AliCDBEntry* entryCpv = AliCDBManager::Instance()->Get(fCpvDataPath.Data(),runNumber);
77   if(entryCpv)
78     fCalibDataCpv = (AliPHOSCpvCalibData*)entryCpv->GetObject();
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
127   fCalibDataEmc->Reset();
128   fCalibDataCpv->Reset();
129 }
130
131 //________________________________________________________________
132 void  AliPHOSCalibData::Print(Option_t *option) const
133 {
134   // Print EMC and CPV calibration containers
135   // Input: option="ped"  to print pedestals
136   //        option="gain" to print calibration coefficients
137   if (fCalibDataEmc) fCalibDataEmc->Print(option);
138   if (fCalibDataCpv) fCalibDataCpv->Print(option);
139 }
140
141 //________________________________________________________________
142 void AliPHOSCalibData::CreateNew()
143 {
144   // Create new EMC and CPV calibration containers with ideal coefficients
145
146   if(fCalibDataEmc) delete fCalibDataEmc;
147   fCalibDataEmc = new AliPHOSEmcCalibData("PHOS-EMC");
148
149   if(fCalibDataCpv) delete fCalibDataCpv;
150   fCalibDataCpv = new AliPHOSCpvCalibData("PHOS-CPV");
151
152   if(fEmcBadChannelsMap) delete fEmcBadChannelsMap;
153   fEmcBadChannelsMap = new AliPHOSEmcBadChannelsMap();
154
155 }
156
157 //________________________________________________________________
158 Bool_t AliPHOSCalibData::WriteEmc(Int_t firstRun, Int_t lastRun, AliCDBMetaData *md)
159 {
160   // Write EMC calibration container to CDB
161
162   if(!fCalibDataEmc) return kFALSE;
163
164   AliCDBStorage* storage = AliCDBManager::Instance()->GetSpecificStorage("PHOS/*");
165   if(!storage)
166     storage = AliCDBManager::Instance()->GetDefaultStorage();
167
168   if(storage) { 
169     AliCDBId id(fEmcDataPath.Data(),firstRun,lastRun);
170     storage->Put(fCalibDataEmc,id, md);
171     return kTRUE;
172   }
173   else
174     return kFALSE;
175
176 }
177
178 //________________________________________________________________
179 Bool_t AliPHOSCalibData::WriteCpv(Int_t firstRun, Int_t lastRun, AliCDBMetaData *md)
180 {
181   // Write CPV calibration container to CDB
182
183   if(!fCalibDataCpv) return kFALSE;
184   
185   AliCDBStorage* storage = AliCDBManager::Instance()->GetSpecificStorage("PHOS/*");
186   if(!storage)
187     storage = AliCDBManager::Instance()->GetDefaultStorage();
188
189   if(storage) { 
190     AliCDBId id(fCpvDataPath.Data(),firstRun,lastRun);
191     storage->Put(fCalibDataCpv,id, md);
192     return kTRUE;
193   }
194   else
195     return kFALSE;
196
197 }
198
199
200 //________________________________________________________________
201 Bool_t AliPHOSCalibData::WriteEmcBadChannelsMap(Int_t firstRun,Int_t lastRun,AliCDBMetaData *md)
202 {
203   //Write EMC bad channels map into CDB.
204
205   if(!fEmcBadChannelsMap) return kFALSE;
206   
207   AliCDBStorage* storage = AliCDBManager::Instance()->GetSpecificStorage("PHOS/*");
208   if(!storage)
209     storage = AliCDBManager::Instance()->GetDefaultStorage();
210
211   if(storage) { 
212     AliCDBId id(fEmcBadChannelsMapPath.Data(),firstRun,lastRun);
213     storage->Put(fEmcBadChannelsMap,id, md);
214     return kTRUE;
215   }
216   else
217     return kFALSE;
218 }
219
220 //________________________________________________________________
221 Float_t AliPHOSCalibData::GetADCchannelEmc(Int_t module, Int_t column, Int_t row) const
222 {
223   // Return EMC calibration coefficient
224   // for channel defined by (module,column,row)
225   // module, column,raw should follow the internal PHOS convention:
226   // module 1:5, column 1:56, row 1:64
227   // if CBD instance exists, the value is taken from CDB.
228   // Otherwise it is an ideal one
229
230   if(fCalibDataEmc) 
231     return fCalibDataEmc->GetADCchannelEmc(module,column,row);
232   else
233     return 1.0; // default width of one EMC ADC channel in GeV
234 }
235
236 //________________________________________________________________
237 Float_t AliPHOSCalibData::GetADCpedestalEmc(Int_t module, Int_t column, Int_t row) const
238 {
239   // Return EMC pedestal for channel defined by (module,column,row)
240   // module, column,raw should follow the internal PHOS convention:
241   // module 1:5, column 1:56, row 1:64
242   // if CBD instance exists, the value is taken from CDB.
243   // Otherwise it is an ideal one
244
245   if(fCalibDataEmc) 
246     return fCalibDataEmc->GetADCpedestalEmc(module,column,row);
247   else
248     return 0.0; // default EMC ADC pedestal
249 }
250
251 //________________________________________________________________
252 void AliPHOSCalibData::SetADCchannelEmc(Int_t module, Int_t column, Int_t row, Float_t value)
253 {
254   // Set EMC calibration coefficient for (module,column,row)
255
256   if(!fCalibDataEmc)
257     fCalibDataEmc = new AliPHOSEmcCalibData("PHOS-EMC");
258
259   fCalibDataEmc->SetADCchannelEmc(module,column,row,value);
260 }
261
262 //________________________________________________________________
263 void AliPHOSCalibData::SetADCpedestalEmc(Int_t module, Int_t column, Int_t row, Float_t value)
264 {
265   // Set EMC pedestal for (module,column,row)
266
267   if(!fCalibDataEmc)
268     fCalibDataEmc = new AliPHOSEmcCalibData("PHOS-EMC");
269
270   fCalibDataEmc->SetADCpedestalEmc(module,column,row,value);
271 }
272
273 //________________________________________________________________
274 Float_t AliPHOSCalibData::GetADCchannelCpv(Int_t module, Int_t column, Int_t row) const
275 {
276   // Return CPV calibration coefficient
277   // for channel defined by (module,column,row)
278   // module, column,raw should follow the internal CPV convention:
279   // module 1:5, column 1:56, row 1:128
280   // if CBD instance exists, the value is taken from CDB.
281   // Otherwise it is an ideal one
282
283   if(fCalibDataCpv) 
284     return fCalibDataCpv->GetADCchannelCpv(module,column,row);
285   else
286     return 0.0012; // default width of one ADC channel in CPV arbitrary units
287 }
288
289 //________________________________________________________________
290 Float_t AliPHOSCalibData::GetADCpedestalCpv(Int_t module, Int_t column, Int_t row) const
291 {
292   // Return CPV pedestal
293   // for channel defined by (module,column,row)
294   // module, column,raw should follow the internal CPV convention:
295   // module 1:5, column 1:56, row 1:128
296   // if CBD instance exists, the value is taken from CDB.
297   // Otherwise it is an ideal one
298
299   if(fCalibDataCpv) 
300     return fCalibDataCpv->GetADCpedestalCpv(module,column,row);
301   else
302     return 0.012; // default CPV ADC pedestal
303 }
304
305 //________________________________________________________________
306 void AliPHOSCalibData::SetADCchannelCpv(Int_t module, Int_t column, Int_t row, Float_t value)
307 {
308   // Set CPV calibration coefficient for (module,column,row)
309
310   if(!fCalibDataCpv)
311     fCalibDataCpv = new AliPHOSCpvCalibData("PHOS-CPV");
312
313   fCalibDataCpv->SetADCchannelCpv(module,column,row,value);
314 }
315
316 //________________________________________________________________
317 void AliPHOSCalibData::SetADCpedestalCpv(Int_t module, Int_t column, Int_t row, Float_t value)
318 {
319   // Set CPV pedestal for (module,column,row)
320
321   if(!fCalibDataCpv)
322     fCalibDataCpv = new AliPHOSCpvCalibData("PHOS-CPV");
323
324   fCalibDataCpv->SetADCpedestalCpv(module,column,row,value);
325 }
326
327 //________________________________________________________________
328 void AliPHOSCalibData::RandomEmc(Float_t ccMin, Float_t ccMax)
329 {
330   // Create decalibrated EMC with calibration coefficients and pedestals
331   // randomly distributed within hard-coded limits
332   // Default spread of calibration parameters is Cmax/Cmin = 4, (Cmax-Cmin)/2 = 1
333
334   if(fCalibDataEmc) delete fCalibDataEmc;
335   fCalibDataEmc = new AliPHOSEmcCalibData("PHOS-EMC");
336
337   TRandom rn;
338   rn.SetSeed(0); //the seed is set to the current  machine clock
339   
340   Float_t adcChannelEmc,adcPedestalEmc;
341
342   for(Int_t module=1; module<6; module++) {
343     for(Int_t column=1; column<57; column++) {
344       for(Int_t row=1; row<65; row++) {
345         adcChannelEmc =rn.Uniform(ccMin,ccMax);
346         adcPedestalEmc=rn.Uniform(0.0,0.0); // 0 spread of pedestals
347         fCalibDataEmc->SetADCchannelEmc(module,column,row,adcChannelEmc);
348         fCalibDataEmc->SetADCpedestalEmc(module,column,row,adcPedestalEmc);
349       }
350     }
351   }
352
353 }
354
355 //________________________________________________________________
356 void AliPHOSCalibData::RandomCpv(Float_t ccMin, Float_t ccMax)
357 {
358   // Create decalibrated CPV with calibration coefficients and pedestals
359   // randomly distributed within hard-coded limits
360   // Default spread of calibration parameters is  0.0012 +- 25%
361
362   if(fCalibDataCpv) delete fCalibDataCpv;
363   fCalibDataCpv = new AliPHOSCpvCalibData("PHOS-CPV");
364
365   TRandom rn;
366   rn.SetSeed(0); //the seed is set to the current  machine clock
367   
368   Float_t adcChannelCpv,adcPedestalCpv;
369
370   for(Int_t module=1; module<6; module++) {
371     for(Int_t column=1; column<57; column++) {
372       for(Int_t row=1; row<129; row++) {
373         adcChannelCpv =rn.Uniform(ccMin,ccMax);
374         adcPedestalCpv=rn.Uniform(0.0048,0.0192); // Ped[max]/Ped[min] = 4, <Ped> = 0.012
375         fCalibDataCpv->SetADCchannelCpv(module,column,row,adcChannelCpv);
376         fCalibDataCpv->SetADCpedestalCpv(module,column,row,adcPedestalCpv);
377       }
378     }
379   }
380 }
381
382 //________________________________________________________________
383 Bool_t AliPHOSCalibData::IsBadChannelEmc(Int_t module, Int_t col, Int_t row) const
384 {
385   //If no bad channels map found, channel considered good
386
387   if(fEmcBadChannelsMap) 
388     return fEmcBadChannelsMap->IsBadChannel(module,col,row);
389   else
390     return kFALSE;
391 }
392
393 //________________________________________________________________
394 Int_t AliPHOSCalibData::GetNumOfEmcBadChannels() const
395 {
396   if(fEmcBadChannelsMap)
397     return fEmcBadChannelsMap->GetNumOfBadChannels();
398   else
399     return 0;
400 }