]>
Commit | Line | Data |
---|---|---|
52783dbc | 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 | ||
fc6706cb | 24 | #include "TRandom.h" |
76d78b7a | 25 | #include "AliLog.h" |
52783dbc | 26 | #include "AliPHOSCalibData.h" |
fc6706cb | 27 | #include "AliCDBManager.h" |
28 | #include "AliCDBStorage.h" | |
29 | #include "AliCDBId.h" | |
30 | #include "AliCDBEntry.h" | |
1fdb1c5e | 31 | #include "AliPHOSEmcCalibData.h" |
32 | #include "AliPHOSCpvCalibData.h" | |
81701069 | 33 | #include "AliPHOSEmcBadChannelsMap.h" |
1fdb1c5e | 34 | #include "AliCDBMetaData.h" |
52783dbc | 35 | |
36 | ClassImp(AliPHOSCalibData) | |
37 | ||
38 | //________________________________________________________________ | |
fc6706cb | 39 | AliPHOSCalibData::AliPHOSCalibData(): |
3f7dbdb7 | 40 | TNamed(), |
41 | fCalibDataEmc(0x0), | |
42 | fCalibDataCpv(0x0), | |
81701069 | 43 | fEmcBadChannelsMap(0x0), |
3f7dbdb7 | 44 | fEmcDataPath("PHOS/Calib/EmcGainPedestals"), |
81701069 | 45 | fCpvDataPath("PHOS/Calib/CpvGainPedestals"), |
46 | fEmcBadChannelsMapPath("PHOS/Calib/EmcBadChannels") | |
52783dbc | 47 | { |
76d78b7a | 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 | |
3f7dbdb7 | 51 | |
81701069 | 52 | AliCDBEntry* entryEmc = AliCDBManager::Instance()->Get(fEmcDataPath.Data()); |
abcff5fc | 53 | if(entryEmc) |
54 | fCalibDataEmc = (AliPHOSEmcCalibData*)entryEmc->GetObject(); | |
76d78b7a | 55 | |
56 | if(!fCalibDataEmc) | |
57 | AliFatal("Calibration parameters for PHOS EMC not found. Stop reconstruction!\n"); | |
58 | ||
abcff5fc | 59 | AliCDBEntry* entryCpv = AliCDBManager::Instance()->Get(fCpvDataPath.Data()); |
60 | if(entryCpv) | |
61 | fCalibDataCpv = (AliPHOSCpvCalibData*)entryCpv->GetObject(); | |
62 | ||
76d78b7a | 63 | if(!fCalibDataCpv) |
64 | AliFatal("Calibration parameters for PHOS CPV not found. Stop reconstruction!\n"); | |
65 | ||
81701069 | 66 | AliCDBEntry* entryEmcBadMap = AliCDBManager::Instance()->Get(fEmcBadChannelsMapPath.Data()); |
67 | if(entryEmcBadMap) | |
68 | fEmcBadChannelsMap = (AliPHOSEmcBadChannelsMap*)entryEmcBadMap->GetObject(); | |
69 | ||
52783dbc | 70 | } |
71 | ||
72 | //________________________________________________________________ | |
fc6706cb | 73 | AliPHOSCalibData::AliPHOSCalibData(Int_t runNumber) : |
74 | TNamed("phosCalib","PHOS Calibration Data Manager"), | |
81701069 | 75 | fCalibDataEmc(0x0), fCalibDataCpv(0x0), fEmcBadChannelsMap(0x0), |
3f7dbdb7 | 76 | fEmcDataPath("PHOS/Calib/EmcGainPedestals"), |
81701069 | 77 | fCpvDataPath("PHOS/Calib/CpvGainPedestals"), |
78 | fEmcBadChannelsMapPath("PHOS/Calib/EmcBadChannels") | |
52783dbc | 79 | { |
80 | // Constructor | |
76d78b7a | 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 | ||
fc6706cb | 84 | AliCDBEntry* entryEmc = AliCDBManager::Instance()->Get(fEmcDataPath.Data(),runNumber); |
85 | if(entryEmc) | |
86 | fCalibDataEmc = (AliPHOSEmcCalibData*)entryEmc->GetObject(); | |
76d78b7a | 87 | |
88 | if(!fCalibDataEmc) | |
89 | AliFatal("Calibration parameters for PHOS EMC not found. Stop reconstruction!\n"); | |
fc6706cb | 90 | |
91 | AliCDBEntry* entryCpv = AliCDBManager::Instance()->Get(fCpvDataPath.Data(),runNumber); | |
92 | if(entryCpv) | |
93 | fCalibDataCpv = (AliPHOSCpvCalibData*)entryCpv->GetObject(); | |
52783dbc | 94 | |
76d78b7a | 95 | if(!fCalibDataCpv) |
96 | AliFatal("Calibration parameters for PHOS CPV not found. Stop reconstruction!\n"); | |
97 | ||
81701069 | 98 | AliCDBEntry* entryEmcBadMap = AliCDBManager::Instance()-> |
99 | Get(fEmcBadChannelsMapPath.Data(),runNumber); | |
100 | if(entryEmcBadMap) | |
101 | fEmcBadChannelsMap = (AliPHOSEmcBadChannelsMap*)entryEmcBadMap->GetObject(); | |
102 | ||
52783dbc | 103 | } |
104 | ||
1fdb1c5e | 105 | //________________________________________________________________ |
106 | AliPHOSCalibData::AliPHOSCalibData(AliPHOSCalibData & phosCDB) : | |
3f7dbdb7 | 107 | TNamed(phosCDB), |
108 | fCalibDataEmc(phosCDB.fCalibDataEmc), | |
109 | fCalibDataCpv(phosCDB.fCalibDataCpv), | |
81701069 | 110 | fEmcBadChannelsMap(phosCDB.fEmcBadChannelsMap), |
3f7dbdb7 | 111 | fEmcDataPath(phosCDB.fEmcDataPath), |
81701069 | 112 | fCpvDataPath(phosCDB.fCpvDataPath), |
113 | fEmcBadChannelsMapPath(phosCDB.fEmcBadChannelsMapPath) | |
1fdb1c5e | 114 | { |
115 | // Copy constructor | |
1fdb1c5e | 116 | } |
52783dbc | 117 | //________________________________________________________________ |
118 | AliPHOSCalibData::~AliPHOSCalibData() | |
119 | { | |
120 | // Destructor | |
fc6706cb | 121 | |
52783dbc | 122 | } |
123 | ||
3f7dbdb7 | 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; | |
81701069 | 132 | fEmcBadChannelsMap = rhs.fEmcBadChannelsMap; |
3f7dbdb7 | 133 | fEmcDataPath = rhs.fEmcDataPath; |
134 | fCpvDataPath = rhs.fCpvDataPath; | |
81701069 | 135 | fEmcBadChannelsMapPath = rhs.fEmcBadChannelsMapPath; |
3f7dbdb7 | 136 | |
137 | return *this; | |
138 | } | |
139 | ||
52783dbc | 140 | //________________________________________________________________ |
141 | void AliPHOSCalibData::Reset() | |
142 | { | |
143 | // Set all pedestals to 0 and all ADC channels to 1 | |
fc6706cb | 144 | |
145 | fCalibDataEmc->Reset(); | |
146 | fCalibDataCpv->Reset(); | |
52783dbc | 147 | } |
148 | ||
149 | //________________________________________________________________ | |
150 | void AliPHOSCalibData::Print(Option_t *option) const | |
151 | { | |
1fdb1c5e | 152 | // Print EMC and CPV calibration containers |
153 | // Input: option="ped" to print pedestals | |
154 | // option="gain" to print calibration coefficients | |
df0d5123 | 155 | if (fCalibDataEmc) fCalibDataEmc->Print(option); |
156 | if (fCalibDataCpv) fCalibDataCpv->Print(option); | |
fc6706cb | 157 | } |
158 | ||
159 | //________________________________________________________________ | |
160 | void AliPHOSCalibData::CreateNew() | |
161 | { | |
1fdb1c5e | 162 | // Create new EMC and CPV calibration containers with ideal coefficients |
163 | ||
fc6706cb | 164 | if(fCalibDataEmc) delete fCalibDataEmc; |
165 | fCalibDataEmc = new AliPHOSEmcCalibData("PHOS-EMC"); | |
166 | ||
167 | if(fCalibDataCpv) delete fCalibDataCpv; | |
168 | fCalibDataCpv = new AliPHOSCpvCalibData("PHOS-CPV"); | |
169 | ||
81701069 | 170 | if(fEmcBadChannelsMap) delete fEmcBadChannelsMap; |
171 | fEmcBadChannelsMap = new AliPHOSEmcBadChannelsMap(); | |
172 | ||
fc6706cb | 173 | } |
174 | ||
175 | //________________________________________________________________ | |
176 | Bool_t AliPHOSCalibData::WriteEmc(Int_t firstRun, Int_t lastRun, AliCDBMetaData *md) | |
177 | { | |
1fdb1c5e | 178 | // Write EMC calibration container to CDB |
fc6706cb | 179 | |
180 | if(!fCalibDataEmc) return kFALSE; | |
181 | ||
18669c5c | 182 | AliCDBStorage* storage = AliCDBManager::Instance()->GetSpecificStorage("PHOS/*"); |
df0d5123 | 183 | if(!storage) |
184 | storage = AliCDBManager::Instance()->GetDefaultStorage(); | |
185 | ||
fc6706cb | 186 | if(storage) { |
187 | AliCDBId id(fEmcDataPath.Data(),firstRun,lastRun); | |
188 | storage->Put(fCalibDataEmc,id, md); | |
189 | return kTRUE; | |
52783dbc | 190 | } |
fc6706cb | 191 | else |
192 | return kFALSE; | |
52783dbc | 193 | |
fc6706cb | 194 | } |
195 | ||
196 | //________________________________________________________________ | |
197 | Bool_t AliPHOSCalibData::WriteCpv(Int_t firstRun, Int_t lastRun, AliCDBMetaData *md) | |
198 | { | |
1fdb1c5e | 199 | // Write CPV calibration container to CDB |
fc6706cb | 200 | |
201 | if(!fCalibDataCpv) return kFALSE; | |
202 | ||
18669c5c | 203 | AliCDBStorage* storage = AliCDBManager::Instance()->GetSpecificStorage("PHOS/*"); |
df0d5123 | 204 | if(!storage) |
205 | storage = AliCDBManager::Instance()->GetDefaultStorage(); | |
206 | ||
fc6706cb | 207 | if(storage) { |
208 | AliCDBId id(fCpvDataPath.Data(),firstRun,lastRun); | |
209 | storage->Put(fCalibDataCpv,id, md); | |
210 | return kTRUE; | |
52783dbc | 211 | } |
fc6706cb | 212 | else |
213 | return kFALSE; | |
214 | ||
52783dbc | 215 | } |
072de3a8 | 216 | |
81701069 | 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 | ||
fc6706cb | 238 | //________________________________________________________________ |
072de3a8 | 239 | Float_t AliPHOSCalibData::GetADCchannelEmc(Int_t module, Int_t column, Int_t row) const |
240 | { | |
1fdb1c5e | 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 | |
072de3a8 | 247 | |
fc6706cb | 248 | if(fCalibDataEmc) |
249 | return fCalibDataEmc->GetADCchannelEmc(module,column,row); | |
250 | else | |
5f8bb860 | 251 | return 1.0; // default width of one EMC ADC channel in GeV |
072de3a8 | 252 | } |
253 | ||
1fdb1c5e | 254 | //________________________________________________________________ |
072de3a8 | 255 | Float_t AliPHOSCalibData::GetADCpedestalEmc(Int_t module, Int_t column, Int_t row) const |
256 | { | |
1fdb1c5e | 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 | ||
fc6706cb | 263 | if(fCalibDataEmc) |
264 | return fCalibDataEmc->GetADCpedestalEmc(module,column,row); | |
265 | else | |
5f8bb860 | 266 | return 0.0; // default EMC ADC pedestal |
072de3a8 | 267 | } |
268 | ||
1fdb1c5e | 269 | //________________________________________________________________ |
072de3a8 | 270 | void AliPHOSCalibData::SetADCchannelEmc(Int_t module, Int_t column, Int_t row, Float_t value) |
271 | { | |
1fdb1c5e | 272 | // Set EMC calibration coefficient for (module,column,row) |
273 | ||
fc6706cb | 274 | if(!fCalibDataEmc) |
275 | fCalibDataEmc = new AliPHOSEmcCalibData("PHOS-EMC"); | |
276 | ||
277 | fCalibDataEmc->SetADCchannelEmc(module,column,row,value); | |
072de3a8 | 278 | } |
279 | ||
1fdb1c5e | 280 | //________________________________________________________________ |
072de3a8 | 281 | void AliPHOSCalibData::SetADCpedestalEmc(Int_t module, Int_t column, Int_t row, Float_t value) |
282 | { | |
1fdb1c5e | 283 | // Set EMC pedestal for (module,column,row) |
284 | ||
fc6706cb | 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 | { | |
1fdb1c5e | 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 | |
fc6706cb | 300 | |
301 | if(fCalibDataCpv) | |
302 | return fCalibDataCpv->GetADCchannelCpv(module,column,row); | |
303 | else | |
5f8bb860 | 304 | return 0.0012; // default width of one ADC channel in CPV arbitrary units |
fc6706cb | 305 | } |
306 | ||
1fdb1c5e | 307 | //________________________________________________________________ |
fc6706cb | 308 | Float_t AliPHOSCalibData::GetADCpedestalCpv(Int_t module, Int_t column, Int_t row) const |
309 | { | |
1fdb1c5e | 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 | ||
fc6706cb | 317 | if(fCalibDataCpv) |
318 | return fCalibDataCpv->GetADCpedestalCpv(module,column,row); | |
319 | else | |
320 | return 0.012; // default CPV ADC pedestal | |
321 | } | |
322 | ||
1fdb1c5e | 323 | //________________________________________________________________ |
fc6706cb | 324 | void AliPHOSCalibData::SetADCchannelCpv(Int_t module, Int_t column, Int_t row, Float_t value) |
325 | { | |
1fdb1c5e | 326 | // Set CPV calibration coefficient for (module,column,row) |
327 | ||
fc6706cb | 328 | if(!fCalibDataCpv) |
329 | fCalibDataCpv = new AliPHOSCpvCalibData("PHOS-CPV"); | |
330 | ||
331 | fCalibDataCpv->SetADCchannelCpv(module,column,row,value); | |
332 | } | |
333 | ||
1fdb1c5e | 334 | //________________________________________________________________ |
fc6706cb | 335 | void AliPHOSCalibData::SetADCpedestalCpv(Int_t module, Int_t column, Int_t row, Float_t value) |
336 | { | |
1fdb1c5e | 337 | // Set CPV pedestal for (module,column,row) |
338 | ||
fc6706cb | 339 | if(!fCalibDataCpv) |
340 | fCalibDataCpv = new AliPHOSCpvCalibData("PHOS-CPV"); | |
341 | ||
342 | fCalibDataCpv->SetADCpedestalCpv(module,column,row,value); | |
343 | } | |
344 | ||
345 | //________________________________________________________________ | |
e2e977c3 | 346 | void AliPHOSCalibData::RandomEmc(Float_t ccMin, Float_t ccMax) |
fc6706cb | 347 | { |
1fdb1c5e | 348 | // Create decalibrated EMC with calibration coefficients and pedestals |
349 | // randomly distributed within hard-coded limits | |
e2e977c3 | 350 | // Default spread of calibration parameters is Cmax/Cmin = 4, (Cmax-Cmin)/2 = 1 |
fc6706cb | 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 | ||
1fdb1c5e | 358 | Float_t adcChannelEmc,adcPedestalEmc; |
fc6706cb | 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++) { | |
e2e977c3 | 363 | adcChannelEmc =rn.Uniform(ccMin,ccMax); |
5f8bb860 | 364 | adcPedestalEmc=rn.Uniform(0.0,0.0); // 0 spread of pedestals |
1fdb1c5e | 365 | fCalibDataEmc->SetADCchannelEmc(module,column,row,adcChannelEmc); |
366 | fCalibDataEmc->SetADCpedestalEmc(module,column,row,adcPedestalEmc); | |
fc6706cb | 367 | } |
368 | } | |
369 | } | |
370 | ||
371 | } | |
372 | ||
373 | //________________________________________________________________ | |
e2e977c3 | 374 | void AliPHOSCalibData::RandomCpv(Float_t ccMin, Float_t ccMax) |
fc6706cb | 375 | { |
1fdb1c5e | 376 | // Create decalibrated CPV with calibration coefficients and pedestals |
377 | // randomly distributed within hard-coded limits | |
e2e977c3 | 378 | // Default spread of calibration parameters is 0.0012 +- 25% |
fc6706cb | 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 | ||
1fdb1c5e | 386 | Float_t adcChannelCpv,adcPedestalCpv; |
fc6706cb | 387 | |
388 | for(Int_t module=1; module<6; module++) { | |
5f8bb860 | 389 | for(Int_t column=1; column<57; column++) { |
fc6706cb | 390 | for(Int_t row=1; row<129; row++) { |
e2e977c3 | 391 | adcChannelCpv =rn.Uniform(ccMin,ccMax); |
1fdb1c5e | 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); | |
fc6706cb | 395 | } |
396 | } | |
397 | } | |
072de3a8 | 398 | } |
81701069 | 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 | } | |
d940eb29 | 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 | } |