]>
Commit | Line | Data |
---|---|---|
a235e2bc | 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 | **************************************************************************/ | |
59ed788d | 15 | //* $Id$ */ |
a235e2bc | 16 | |
17 | //________________________________________________________________________ | |
18 | // | |
19 | // A help class for monitoring and calibration tools: MOOD, AMORE etc., | |
20 | // It can be created and used a la (ctor): | |
21 | /* | |
22 | //Create the object for making the histograms | |
23 | fPedestals = new AliCaloCalibPedestal( fDetType ); | |
24 | // AliCaloCalibPedestal knows how many modules we have for PHOS or EMCAL | |
25 | fNumModules = fPedestals->GetModules(); | |
26 | */ | |
27 | // fed an event: | |
28 | // fPedestals->ProcessEvent(fCaloRawStream); | |
29 | // asked to draw histograms: | |
30 | // fPedestals->GetDeadMap(i)->Draw("col"); | |
31 | // or | |
32 | // fPedestals->GetPeakProfileHighGainRatio((i < fNumModules) ? i : fVisibleModule)->Draw("colz"); | |
33 | // etc. | |
34 | // The pseudo-code examples above were from the first implementation in MOOD (summer 2007). | |
35 | //________________________________________________________________________ | |
36 | ||
59ed788d | 37 | //#include "TCanvas.h" |
356c3e0c | 38 | #include "TH1.h" |
59ed788d | 39 | #include "TF1.h" |
356c3e0c | 40 | #include "TFile.h" |
356c3e0c | 41 | #include <fstream> |
b07ee441 | 42 | #include <sstream> |
356c3e0c | 43 | #include <iostream> |
c490d8e5 | 44 | #include <stdexcept> |
3dba9483 | 45 | #include <cmath> |
356c3e0c | 46 | |
30aa89b0 | 47 | #include "AliRawReader.h" |
32cd4c24 | 48 | #include "AliCaloRawStreamV3.h" |
a235e2bc | 49 | |
356c3e0c | 50 | //The include file |
51 | #include "AliCaloCalibPedestal.h" | |
52 | ||
53 | ClassImp(AliCaloCalibPedestal) | |
54 | ||
55 | using namespace std; | |
56 | ||
57 | // ctor; initialize everything in order to avoid compiler warnings | |
58 | AliCaloCalibPedestal::AliCaloCalibPedestal(kDetType detectorType) : | |
59 | TObject(), | |
60 | fPedestalLowGain(), | |
61 | fPedestalHighGain(), | |
29f94584 | 62 | fPedestalLEDRefLowGain(), |
63 | fPedestalLEDRefHighGain(), | |
356c3e0c | 64 | fPeakMinusPedLowGain(), |
65 | fPeakMinusPedHighGain(), | |
59ed788d | 66 | fPeakMinusPedHighGainHisto(), |
356c3e0c | 67 | fPedestalLowGainDiff(), |
68 | fPedestalHighGainDiff(), | |
29f94584 | 69 | fPedestalLEDRefLowGainDiff(), |
70 | fPedestalLEDRefHighGainDiff(), | |
356c3e0c | 71 | fPeakMinusPedLowGainDiff(), |
72 | fPeakMinusPedHighGainDiff(), | |
73 | fPedestalLowGainRatio(), | |
74 | fPedestalHighGainRatio(), | |
29f94584 | 75 | fPedestalLEDRefLowGainRatio(), |
76 | fPedestalLEDRefHighGainRatio(), | |
356c3e0c | 77 | fPeakMinusPedLowGainRatio(), |
78 | fPeakMinusPedHighGainRatio(), | |
79 | fDeadMap(), | |
419341ea | 80 | fNEvents(0), |
81 | fNChanFills(0), | |
356c3e0c | 82 | fDeadTowers(0), |
83 | fNewDeadTowers(0), | |
84 | fResurrectedTowers(0), | |
85 | fReference(0), | |
86 | fDetType(kNone), | |
87 | fColumns(0), | |
88 | fRows(0), | |
29f94584 | 89 | fLEDRefs(0), |
356c3e0c | 90 | fModules(0), |
18db89b7 | 91 | fRowMin(0), |
92 | fRowMax(0), | |
93 | fRowMultiplier(0), | |
f4fc542c | 94 | fCaloString(), |
95 | fMapping(NULL), | |
3dba9483 | 96 | fRunNumber(-1), |
97 | fSelectPedestalSamples(kTRUE), | |
98 | fFirstPedestalSample(0), | |
59ed788d | 99 | fLastPedestalSample(15), |
100 | fDeadThreshold(5), | |
101 | fWarningThreshold(50), | |
102 | fWarningFraction(0.002), | |
103 | fHotSigma(5) | |
356c3e0c | 104 | { |
105 | //Default constructor. First we set the detector-type related constants. | |
106 | if (detectorType == kPhos) { | |
107 | fColumns = fgkPhosCols; | |
108 | fRows = fgkPhosRows; | |
29f94584 | 109 | fLEDRefs = fgkPhosLEDRefs; |
356c3e0c | 110 | fModules = fgkPhosModules; |
f4fc542c | 111 | fCaloString = "PHOS"; |
18db89b7 | 112 | fRowMin = -1*fRows; |
113 | fRowMax = 0; | |
114 | fRowMultiplier = -1; | |
356c3e0c | 115 | } |
116 | else { | |
117 | //We'll just trust the enum to keep everything in line, so that if detectorType | |
118 | //isn't kPhos then it is kEmCal. Note, however, that this is not necessarily the | |
119 | //case, if someone intentionally gives another number | |
bd3cd9c2 | 120 | fColumns = AliEMCALGeoParams::fgkEMCALCols; |
121 | fRows = AliEMCALGeoParams::fgkEMCALRows; | |
29f94584 | 122 | fLEDRefs = AliEMCALGeoParams::fgkEMCALLEDRefs; |
bd3cd9c2 | 123 | fModules = AliEMCALGeoParams::fgkEMCALModules; |
f4fc542c | 124 | fCaloString = "EMCAL"; |
18db89b7 | 125 | fRowMin = 0; |
126 | fRowMax = fRows; | |
127 | fRowMultiplier = 1; | |
356c3e0c | 128 | } |
129 | fDetType = detectorType; | |
23ca956b | 130 | |
131 | // ValidateProfiles(); // not to be done in ctor; info from Axel N. | |
132 | } | |
133 | ||
134 | //_____________________________________________________________________ | |
135 | void AliCaloCalibPedestal::ValidateProfiles() | |
136 | { | |
137 | //Make sure the basic histos exist | |
138 | if (!fPedestalLowGain.IsEmpty()) return; //The profiles already exist. We just check one, because they're all created at | |
139 | //the same time | |
140 | ||
356c3e0c | 141 | //Then, loop for the requested number of modules |
142 | TString title, name; | |
143 | for (int i = 0; i < fModules; i++) { | |
144 | //Pedestals, low gain | |
145 | name = "hPedlowgain"; | |
146 | name += i; | |
147 | title = "Pedestals, low gain, module "; | |
148 | title += i; | |
149 | fPedestalLowGain.Add(new TProfile2D(name, title, | |
150 | fColumns, 0.0, fColumns, | |
18db89b7 | 151 | fRows, fRowMin, fRowMax,"s")); |
356c3e0c | 152 | |
153 | //Pedestals, high gain | |
154 | name = "hPedhighgain"; | |
155 | name += i; | |
156 | title = "Pedestals, high gain, module "; | |
157 | title += i; | |
158 | fPedestalHighGain.Add(new TProfile2D(name, title, | |
159 | fColumns, 0.0, fColumns, | |
18db89b7 | 160 | fRows, fRowMin, fRowMax,"s")); |
29f94584 | 161 | |
162 | //LED Ref/Mon pedestals, low gain | |
163 | name = "hPedestalLEDReflowgain"; | |
18db89b7 | 164 | name += i; |
29f94584 | 165 | title = "Pedestal LEDRef, low gain, module "; |
18db89b7 | 166 | title += i; |
29f94584 | 167 | fPedestalLEDRefLowGain.Add(new TProfile(name, title, |
168 | fLEDRefs, 0.0, fLEDRefs, "s")); | |
169 | ||
170 | //LED Ref/Mon pedestals, high gain | |
171 | name = "hPedestalLEDRefhighgain"; | |
18db89b7 | 172 | name += i; |
29f94584 | 173 | title = "Pedestal LEDRef, high gain, module "; |
18db89b7 | 174 | title += i; |
29f94584 | 175 | fPedestalLEDRefHighGain.Add(new TProfile(name, title, |
176 | fLEDRefs, 0.0, fLEDRefs, "s")); | |
356c3e0c | 177 | |
178 | //Peak-Pedestals, low gain | |
179 | name = "hPeakMinusPedlowgain"; | |
180 | name += i; | |
181 | title = "Peak-Pedestal, low gain, module "; | |
182 | title += i; | |
183 | fPeakMinusPedLowGain.Add(new TProfile2D(name, title, | |
184 | fColumns, 0.0, fColumns, | |
18db89b7 | 185 | fRows, fRowMin, fRowMax,"s")); |
356c3e0c | 186 | |
187 | //Peak-Pedestals, high gain | |
188 | name = "hPeakMinusPedhighgain"; | |
189 | name += i; | |
190 | title = "Peak-Pedestal, high gain, module "; | |
191 | title += i; | |
192 | fPeakMinusPedHighGain.Add(new TProfile2D(name, title, | |
193 | fColumns, 0.0, fColumns, | |
18db89b7 | 194 | fRows, fRowMin, fRowMax,"s")); |
59ed788d | 195 | |
196 | //Peak-Pedestals, high gain - TH2F histo | |
197 | name = "hPeakMinusPedhighgainHisto"; | |
198 | name += i; | |
199 | title = "Peak-Pedestal, high gain, module "; | |
200 | title += i; | |
201 | fPeakMinusPedHighGainHisto.Add(new TH2F(name, title, | |
202 | fColumns*fRows, 0.0, fColumns*fRows, | |
203 | 100, 0, 1000)); | |
204 | ||
356c3e0c | 205 | name = "hDeadMap"; |
206 | name += i; | |
207 | title = "Dead map, module "; | |
208 | title += i; | |
209 | fDeadMap.Add(new TH2D(name, title, fColumns, 0.0, fColumns, | |
18db89b7 | 210 | fRows, fRowMin, fRowMax)); |
356c3e0c | 211 | |
212 | }//end for nModules create the histograms | |
23ca956b | 213 | |
214 | CompressAndSetOwner(); | |
215 | } | |
216 | ||
217 | //_____________________________________________________________________ | |
218 | void AliCaloCalibPedestal::CompressAndSetOwner() | |
219 | { | |
356c3e0c | 220 | //Compress the arrays, in order to remove the empty objects (a 16 slot array is created by default) |
221 | fPedestalLowGain.Compress(); | |
222 | fPedestalHighGain.Compress(); | |
29f94584 | 223 | fPedestalLEDRefLowGain.Compress(); |
224 | fPedestalLEDRefHighGain.Compress(); | |
356c3e0c | 225 | fPeakMinusPedLowGain.Compress(); |
226 | fPeakMinusPedHighGain.Compress(); | |
59ed788d | 227 | fPeakMinusPedHighGainHisto.Compress(); |
356c3e0c | 228 | fDeadMap.Compress(); |
29f94584 | 229 | |
61e4e2e3 | 230 | // set owner ship for everyone |
231 | fPedestalLowGain.SetOwner(kTRUE); | |
232 | fPedestalHighGain.SetOwner(kTRUE); | |
233 | fPedestalLEDRefLowGain.SetOwner(kTRUE); | |
234 | fPedestalLEDRefHighGain.SetOwner(kTRUE); | |
235 | fPeakMinusPedLowGain.SetOwner(kTRUE); | |
236 | fPeakMinusPedHighGain.SetOwner(kTRUE); | |
237 | fPeakMinusPedHighGainHisto.SetOwner(kTRUE); | |
238 | fPedestalLowGainDiff.SetOwner(kTRUE); | |
239 | fPedestalHighGainDiff.SetOwner(kTRUE); | |
240 | fPedestalLEDRefLowGainDiff.SetOwner(kTRUE); | |
241 | fPedestalLEDRefHighGainDiff.SetOwner(kTRUE); | |
242 | fPeakMinusPedLowGainDiff.SetOwner(kTRUE); | |
243 | fPeakMinusPedHighGainDiff.SetOwner(kTRUE); | |
244 | fPedestalLowGainRatio.SetOwner(kTRUE); | |
245 | fPedestalHighGainRatio.SetOwner(kTRUE); | |
246 | fPedestalLEDRefLowGainRatio.SetOwner(kTRUE); | |
247 | fPedestalLEDRefHighGainRatio.SetOwner(kTRUE); | |
248 | fPeakMinusPedLowGainRatio.SetOwner(kTRUE); | |
249 | fPeakMinusPedHighGainRatio.SetOwner(kTRUE); | |
250 | fDeadMap.SetOwner(kTRUE); | |
356c3e0c | 251 | } |
252 | ||
253 | // dtor | |
254 | //_____________________________________________________________________ | |
255 | AliCaloCalibPedestal::~AliCaloCalibPedestal() | |
256 | { | |
65bec413 | 257 | //dtor |
65bec413 | 258 | |
f62c044a | 259 | if (fReference) delete fReference;//Delete the reference object, if it has been loaded |
65bec413 | 260 | |
65bec413 | 261 | // delete also TObjArray's |
f62c044a | 262 | fPedestalLowGain.Delete(); |
263 | fPedestalHighGain.Delete(); | |
264 | fPedestalLEDRefLowGain.Delete(); | |
265 | fPedestalLEDRefHighGain.Delete(); | |
266 | fPeakMinusPedLowGain.Delete(); | |
267 | fPeakMinusPedHighGain.Delete(); | |
268 | fPeakMinusPedHighGainHisto.Delete(); | |
269 | fPedestalLowGainDiff.Delete(); | |
270 | fPedestalHighGainDiff.Delete(); | |
271 | fPedestalLEDRefLowGainDiff.Delete(); | |
272 | fPedestalLEDRefHighGainDiff.Delete(); | |
273 | fPeakMinusPedLowGainDiff.Delete(); | |
274 | fPeakMinusPedHighGainDiff.Delete(); | |
275 | fPedestalLowGainRatio.Delete(); | |
276 | fPedestalHighGainRatio.Delete(); | |
277 | fPedestalLEDRefLowGainRatio.Delete(); | |
278 | fPedestalLEDRefHighGainRatio.Delete(); | |
279 | fPeakMinusPedLowGainRatio.Delete(); | |
280 | fPeakMinusPedHighGainRatio.Delete(); | |
281 | fDeadMap.Delete(); | |
65bec413 | 282 | |
356c3e0c | 283 | } |
284 | ||
285 | // copy ctor | |
286 | //_____________________________________________________________________ | |
23ca956b | 287 | AliCaloCalibPedestal::AliCaloCalibPedestal(AliCaloCalibPedestal &ped) : |
356c3e0c | 288 | TObject(ped), |
289 | fPedestalLowGain(), | |
290 | fPedestalHighGain(), | |
29f94584 | 291 | fPedestalLEDRefLowGain(), |
292 | fPedestalLEDRefHighGain(), | |
356c3e0c | 293 | fPeakMinusPedLowGain(), |
294 | fPeakMinusPedHighGain(), | |
59ed788d | 295 | fPeakMinusPedHighGainHisto(), |
356c3e0c | 296 | fPedestalLowGainDiff(), |
297 | fPedestalHighGainDiff(), | |
29f94584 | 298 | fPedestalLEDRefLowGainDiff(), |
299 | fPedestalLEDRefHighGainDiff(), | |
356c3e0c | 300 | fPeakMinusPedLowGainDiff(), |
301 | fPeakMinusPedHighGainDiff(), | |
302 | fPedestalLowGainRatio(), | |
303 | fPedestalHighGainRatio(), | |
29f94584 | 304 | fPedestalLEDRefLowGainRatio(), |
305 | fPedestalLEDRefHighGainRatio(), | |
356c3e0c | 306 | fPeakMinusPedLowGainRatio(), |
307 | fPeakMinusPedHighGainRatio(), | |
308 | fDeadMap(), | |
419341ea | 309 | fNEvents(ped.GetNEvents()), |
310 | fNChanFills(ped.GetNChanFills()), | |
356c3e0c | 311 | fDeadTowers(ped.GetDeadTowerCount()), |
312 | fNewDeadTowers(ped.GetDeadTowerNew()), | |
313 | fResurrectedTowers(ped.GetDeadTowerResurrected()), | |
314 | fReference( 0 ), //! note that we do not try to copy the reference info here | |
315 | fDetType(ped.GetDetectorType()), | |
316 | fColumns(ped.GetColumns()), | |
317 | fRows(ped.GetRows()), | |
29f94584 | 318 | fLEDRefs(ped.GetLEDRefs()), |
356c3e0c | 319 | fModules(ped.GetModules()), |
18db89b7 | 320 | fRowMin(ped.GetRowMin()), |
321 | fRowMax(ped.GetRowMax()), | |
322 | fRowMultiplier(ped.GetRowMultiplier()), | |
f4fc542c | 323 | fCaloString(ped.GetCaloString()), |
324 | fMapping(NULL), //! note that we are not copying the map info | |
3dba9483 | 325 | fRunNumber(ped.GetRunNumber()), |
326 | fSelectPedestalSamples(ped.GetSelectPedestalSamples()), | |
327 | fFirstPedestalSample(ped.GetFirstPedestalSample()), | |
59ed788d | 328 | fLastPedestalSample(ped.GetLastPedestalSample()), |
329 | fDeadThreshold(ped.GetDeadThreshold()), | |
330 | fWarningThreshold(ped.GetWarningThreshold()), | |
331 | fWarningFraction(ped.GetWarningFraction()), | |
332 | fHotSigma(ped.GetHotSigma()) | |
356c3e0c | 333 | { |
334 | // Then the ObjArray ones; we add the histograms rather than trying TObjArray = assignment | |
335 | //DS: this has not really been tested yet.. | |
336 | for (int i = 0; i < fModules; i++) { | |
337 | fPedestalLowGain.Add( ped.GetPedProfileLowGain(i) ); | |
338 | fPedestalHighGain.Add( ped.GetPedProfileHighGain(i) ); | |
29f94584 | 339 | fPedestalLEDRefLowGain.Add( ped.GetPedLEDRefProfileLowGain(i) ); |
340 | fPedestalLEDRefHighGain.Add( ped.GetPedLEDRefProfileHighGain(i) ); | |
356c3e0c | 341 | fPeakMinusPedLowGain.Add( ped.GetPeakProfileLowGain(i) ); |
342 | fPeakMinusPedHighGain.Add( ped.GetPeakProfileHighGain(i) ); | |
59ed788d | 343 | fPeakMinusPedHighGainHisto.Add( ped.GetPeakHighGainHisto(i) ); |
356c3e0c | 344 | |
345 | fDeadMap.Add( ped.GetDeadMap(i) ); | |
346 | }//end for nModules | |
347 | ||
23ca956b | 348 | CompressAndSetOwner(); |
356c3e0c | 349 | } |
350 | ||
351 | // assignment operator; use copy ctor to make life easy.. | |
352 | //_____________________________________________________________________ | |
23ca956b | 353 | AliCaloCalibPedestal& AliCaloCalibPedestal::operator = (AliCaloCalibPedestal &source) |
356c3e0c | 354 | { |
a235e2bc | 355 | // assignment operator; use copy ctor |
356c3e0c | 356 | if (&source == this) return *this; |
357 | ||
358 | new (this) AliCaloCalibPedestal(source); | |
359 | return *this; | |
360 | } | |
361 | ||
362 | //_____________________________________________________________________ | |
363 | void AliCaloCalibPedestal::Reset() | |
364 | { | |
23ca956b | 365 | ValidateProfiles(); // make sure histos/profiles exist |
a235e2bc | 366 | // Reset all arrays/histograms |
356c3e0c | 367 | for (int i = 0; i < fModules; i++) { |
368 | GetPedProfileLowGain(i)->Reset(); | |
369 | GetPedProfileHighGain(i)->Reset(); | |
29f94584 | 370 | GetPedLEDRefProfileLowGain(i)->Reset(); |
371 | GetPedLEDRefProfileHighGain(i)->Reset(); | |
356c3e0c | 372 | GetPeakProfileLowGain(i)->Reset(); |
373 | GetPeakProfileHighGain(i)->Reset(); | |
59ed788d | 374 | GetPeakHighGainHisto(i)->Reset(); |
356c3e0c | 375 | GetDeadMap(i)->Reset(); |
376 | ||
377 | if (!fPedestalLowGainDiff.IsEmpty()) { | |
378 | //This means that the comparison profiles have been created. | |
379 | ||
380 | GetPedProfileLowGainDiff(i)->Reset(); | |
381 | GetPedProfileHighGainDiff(i)->Reset(); | |
29f94584 | 382 | GetPedLEDRefProfileLowGainDiff(i)->Reset(); |
383 | GetPedLEDRefProfileHighGainDiff(i)->Reset(); | |
356c3e0c | 384 | GetPeakProfileLowGainDiff(i)->Reset(); |
385 | GetPeakProfileHighGainDiff(i)->Reset(); | |
386 | ||
387 | GetPedProfileLowGainRatio(i)->Reset(); | |
388 | GetPedProfileHighGainRatio(i)->Reset(); | |
29f94584 | 389 | GetPedLEDRefProfileLowGainRatio(i)->Reset(); |
390 | GetPedLEDRefProfileHighGainRatio(i)->Reset(); | |
356c3e0c | 391 | GetPeakProfileLowGainRatio(i)->Reset(); |
392 | GetPeakProfileHighGainRatio(i)->Reset(); | |
393 | } | |
394 | } | |
419341ea | 395 | fNEvents = 0; |
396 | fNChanFills = 0; | |
356c3e0c | 397 | fDeadTowers = 0; |
398 | fNewDeadTowers = 0; | |
399 | fResurrectedTowers = 0; | |
400 | ||
401 | //To think about: should fReference be deleted too?... let's not do it this time, at least... | |
402 | } | |
403 | ||
b07ee441 | 404 | // Parameter/cut handling |
405 | //_____________________________________________________________________ | |
406 | void AliCaloCalibPedestal::SetParametersFromFile(const char *parameterFile) | |
40164976 | 407 | { |
408 | // Note: this method is a bit more complicated than it really has to be | |
409 | // - allowing for multiple entries per line, arbitrary order of the | |
410 | // different variables etc. But I wanted to try and do this in as | |
411 | // correct a C++ way as I could (as an exercise). | |
412 | ||
b07ee441 | 413 | static const string delimitor("::"); |
414 | ||
415 | // open, check input file | |
416 | ifstream in( parameterFile ); | |
417 | if( !in ) { | |
418 | printf("in AliCaloCalibPedestal::SetParametersFromFile - Using default/run_time parameters.\n"); | |
419 | return; | |
420 | } | |
421 | ||
b07ee441 | 422 | |
423 | // read in | |
424 | char readline[1024]; | |
425 | while ((in.rdstate() & ios::failbit) == 0 ) { | |
426 | ||
427 | // Read into the raw char array and then construct a string | |
428 | // to do the searching | |
429 | in.getline(readline, 1024); | |
430 | istringstream s(readline); | |
431 | ||
432 | while ( ( s.rdstate() & ios::failbit ) == 0 ) { | |
433 | ||
ab962f7b | 434 | string keyValue; |
435 | s >> keyValue; | |
b07ee441 | 436 | |
437 | // check stream status | |
b63770f3 | 438 | if( ( s.rdstate() & ios::failbit ) == ios::failbit) break; |
b07ee441 | 439 | |
440 | // skip rest of line if comments found | |
ab962f7b | 441 | if( keyValue.substr( 0, 2 ) == "//" ) break; |
b07ee441 | 442 | |
ab962f7b | 443 | // look for "::" in keyValue pair |
444 | size_t position = keyValue.find( delimitor ); | |
b07ee441 | 445 | if( position == string::npos ) { |
ab962f7b | 446 | printf("wrong format for key::value pair: %s\n", keyValue.c_str()); |
b07ee441 | 447 | } |
448 | ||
ab962f7b | 449 | // split keyValue pair |
450 | string key( keyValue.substr( 0, position ) ); | |
451 | string value( keyValue.substr( position+delimitor.size(), | |
452 | keyValue.size()-delimitor.size() ) ); | |
b07ee441 | 453 | |
454 | // check value does not contain a new delimitor | |
455 | if( value.find( delimitor ) != string::npos ) { | |
ab962f7b | 456 | printf("wrong format for key::value pair: %s\n", keyValue.c_str()); |
b07ee441 | 457 | } |
458 | ||
459 | // debug: check key value pair | |
460 | // printf("AliCaloCalibPedestal::SetParametersFromFile - key %s value %s\n", key.c_str(), value.c_str()); | |
461 | ||
462 | // if the key matches with something we expect, we assign the new value | |
463 | istringstream iss(value); | |
464 | // the comparison strings defined at the beginning of this method | |
59ed788d | 465 | if ( (key == "fFirstPedestalSample") || (key == "fLastPedestalSample") || (key == "fDeadThreshold") || (key == "fWarningThreshold") || (key == "fWarningFraction") || (key == "fHotSigma") ) { |
b07ee441 | 466 | printf("AliCaloCalibPedestal::SetParametersFromFile - key %s value %s\n", key.c_str(), value.c_str()); |
467 | ||
468 | if (key == "fFirstPedestalSample") { | |
469 | iss >> fFirstPedestalSample; | |
470 | } | |
471 | else if (key == "fLastPedestalSample") { | |
472 | iss >> fLastPedestalSample; | |
473 | } | |
59ed788d | 474 | else if (key == "fDeadThreshold") { |
475 | iss >> fDeadThreshold; | |
476 | } | |
477 | else if (key == "fWarningThreshold") { | |
478 | iss >> fWarningThreshold; | |
479 | } | |
480 | else if (key == "fWarningFraction") { | |
481 | iss >> fWarningFraction; | |
482 | } | |
483 | else if (key == "fHotSigma") { | |
484 | iss >> fHotSigma; | |
485 | } | |
486 | ||
b07ee441 | 487 | } // some match |
488 | ||
489 | } | |
490 | } | |
491 | ||
492 | in.close(); | |
493 | return; | |
494 | ||
495 | } | |
496 | ||
497 | //_____________________________________________________________________ | |
498 | void AliCaloCalibPedestal::WriteParametersToFile(const char *parameterFile) | |
499 | { | |
40164976 | 500 | //Write parameters in file. |
501 | ||
b07ee441 | 502 | static const string delimitor("::"); |
503 | ofstream out( parameterFile ); | |
504 | out << "// " << parameterFile << endl; | |
505 | out << "fFirstPedestalSample" << "::" << fFirstPedestalSample << endl; | |
506 | out << "fLastPedestalSample" << "::" << fLastPedestalSample << endl; | |
59ed788d | 507 | out << "fDeadThreshold" << "::" << fDeadThreshold << endl; |
508 | out << "fWarningThreshold" << "::" << fWarningThreshold << endl; | |
509 | out << "fWarningFraction" << "::" << fWarningFraction << endl; | |
510 | out << "fHotSigma" << "::" << fHotSigma << endl; | |
b07ee441 | 511 | |
512 | out.close(); | |
513 | return; | |
514 | } | |
515 | ||
419341ea | 516 | //_____________________________________________________________________ |
23ca956b | 517 | Bool_t AliCaloCalibPedestal::AddInfo(AliCaloCalibPedestal *ped) |
419341ea | 518 | { |
23ca956b | 519 | ValidateProfiles(); // make sure histos/profiles exist |
419341ea | 520 | // just do this for the basic histograms/profiles that get filled in ProcessEvent |
521 | // may not have data for all modules, but let's just Add everything.. | |
522 | for (int i = 0; i < fModules; i++) { | |
2ce7ee7f | 523 | GetPedProfileLowGain(i)->Add( ped->GetPedProfileLowGain(i) ); |
524 | GetPedProfileHighGain(i)->Add( ped->GetPedProfileHighGain(i) ); | |
fcba0b23 | 525 | GetPedLEDRefProfileLowGain(i)->Add( ped->GetPedLEDRefProfileLowGain(i) ); |
526 | GetPedLEDRefProfileHighGain(i)->Add( ped->GetPedLEDRefProfileHighGain(i) ); | |
2ce7ee7f | 527 | GetPeakProfileLowGain(i)->Add( ped->GetPeakProfileLowGain(i) ); |
528 | GetPeakProfileHighGain(i)->Add( ped->GetPeakProfileHighGain(i) ); | |
59ed788d | 529 | GetPeakHighGainHisto(i)->Add( ped->GetPeakHighGainHisto(i) ); |
530 | ||
419341ea | 531 | }//end for nModules |
532 | ||
533 | // DeadMap; Diff profiles etc would need to be redone after this operation | |
534 | ||
535 | return kTRUE;//We succesfully added info from the supplied object | |
536 | } | |
537 | ||
f4fc542c | 538 | //_____________________________________________________________________ |
539 | Bool_t AliCaloCalibPedestal::ProcessEvent(AliRawReader *rawReader) | |
540 | { | |
541 | // if fMapping is NULL the rawstream will crate its own mapping | |
32cd4c24 | 542 | AliCaloRawStreamV3 rawStream(rawReader, fCaloString, (AliAltroMapping**)fMapping); |
30aa89b0 | 543 | if (fDetType == kEmCal) { |
544 | rawReader->Select("EMCAL", 0, AliEMCALGeoParams::fgkLastAltroDDL) ; //select EMCAL DDL range | |
545 | } | |
f4fc542c | 546 | return ProcessEvent(&rawStream); |
547 | } | |
548 | ||
356c3e0c | 549 | //_____________________________________________________________________ |
32cd4c24 | 550 | Bool_t AliCaloCalibPedestal::ProcessEvent(AliCaloRawStreamV3 *in) |
356c3e0c | 551 | { |
a235e2bc | 552 | // Method to process=analyze one event in the data stream |
356c3e0c | 553 | if (!in) return kFALSE; //Return right away if there's a null pointer |
65bec413 | 554 | in->Reset(); // just in case the next customer forgets to check if the stream was reset.. |
555 | ||
419341ea | 556 | fNEvents++; // one more event |
23ca956b | 557 | |
558 | if (fNEvents==1) ValidateProfiles(); // 1st event, make sure histos/profiles exist | |
3dba9483 | 559 | |
560 | // indices for the reading | |
561 | int sample = 0; | |
3dba9483 | 562 | int time = 0; |
32cd4c24 | 563 | int i = 0; // sample counter |
564 | int startBin = 0; | |
3dba9483 | 565 | |
32cd4c24 | 566 | // start loop over input stream |
567 | while (in->NextDDL()) { | |
568 | while (in->NextChannel()) { | |
3dba9483 | 569 | |
32cd4c24 | 570 | // counters |
bd3cd9c2 | 571 | int max = AliEMCALGeoParams::fgkSampleMin, min = AliEMCALGeoParams::fgkSampleMax; // min and max sample values |
56613d93 | 572 | int nsamples = 0; |
573 | ||
29f94584 | 574 | // pedestal samples |
575 | int nPed = 0; | |
576 | vector<int> pedSamples; | |
577 | ||
32cd4c24 | 578 | while (in->NextBunch()) { |
579 | const UShort_t *sig = in->GetSignals(); | |
580 | startBin = in->GetStartTimeBin(); | |
56613d93 | 581 | nsamples += in->GetBunchLength(); |
32cd4c24 | 582 | for (i = 0; i < in->GetBunchLength(); i++) { |
583 | sample = sig[i]; | |
584 | time = startBin--; | |
585 | ||
586 | // check if it's a min or max value | |
587 | if (sample < min) min = sample; | |
588 | if (sample > max) max = sample; | |
589 | ||
590 | // should we add it for the pedestal calculation? | |
591 | if ( (fFirstPedestalSample<=time && time<=fLastPedestalSample) || // sample time in range | |
592 | !fSelectPedestalSamples ) { // or we don't restrict the sample range.. - then we'll take all | |
29f94584 | 593 | pedSamples.push_back( sig[i] ); |
594 | nPed++; | |
32cd4c24 | 595 | } |
596 | ||
597 | } // loop over samples in bunch | |
598 | } // loop over bunches | |
3dba9483 | 599 | |
56613d93 | 600 | if (nsamples > 0) { // this check is needed for when we have zero-supp. on, but not sparse readout |
601 | ||
32cd4c24 | 602 | // it should be enough to check the SuperModule info for each DDL really, but let's keep it here for now |
356c3e0c | 603 | int arrayPos = in->GetModule(); //The modules are numbered starting from 0 |
604 | if (arrayPos >= fModules) { | |
605 | //TODO: return an error message, if appopriate (perhaps if debug>0?) | |
606 | return kFALSE; | |
32cd4c24 | 607 | } |
356c3e0c | 608 | //Debug |
609 | if (arrayPos < 0 || arrayPos >= fModules) { | |
610 | printf("Oh no: arrayPos = %i.\n", arrayPos); | |
611 | } | |
32cd4c24 | 612 | |
419341ea | 613 | fNChanFills++; // one more channel found, and profile to be filled |
356c3e0c | 614 | //NOTE: coordinates are (column, row) for the profiles |
29f94584 | 615 | if ( in->IsLowGain() ) { |
356c3e0c | 616 | //fill the low gain histograms |
18db89b7 | 617 | ((TProfile2D*)fPeakMinusPedLowGain[arrayPos])->Fill(in->GetColumn(), fRowMultiplier*in->GetRow(), max - min); |
29f94584 | 618 | if (nPed>0) { // only fill pedestal info in case it could be calculated |
619 | for ( i=0; i<nPed; i++) { | |
620 | ((TProfile2D*)fPedestalLowGain[arrayPos])->Fill(in->GetColumn(), fRowMultiplier*in->GetRow(), pedSamples[i]); | |
621 | } | |
3dba9483 | 622 | } |
356c3e0c | 623 | } |
29f94584 | 624 | else if ( in->IsHighGain() ) { |
3dba9483 | 625 | //fill the high gain ones |
18db89b7 | 626 | ((TProfile2D*)fPeakMinusPedHighGain[arrayPos])->Fill(in->GetColumn(), fRowMultiplier*in->GetRow(), max - min); |
29f94584 | 627 | if (nPed>0) { // only fill pedestal info in case it could be calculated |
628 | for ( i=0; i<nPed; i++) { | |
629 | ((TProfile2D*)fPedestalHighGain[arrayPos])->Fill(in->GetColumn(), fRowMultiplier*in->GetRow(), pedSamples[i]); | |
630 | } | |
3dba9483 | 631 | } |
59ed788d | 632 | // for warning checks |
633 | int idx = in->GetRow() + fRows * in->GetColumn(); | |
634 | ((TH2F*)fPeakMinusPedHighGainHisto[arrayPos])->Fill(idx, max - min); | |
29f94584 | 635 | } |
636 | else if ( in->IsLEDMonData() ) { | |
637 | // for LED Mon data, the mapping class holds the gain info in the Row variable | |
638 | // and the Strip number in the Column.. | |
639 | int gain = in->GetRow(); | |
640 | int stripId = in->GetColumn(); | |
641 | if (nPed>0 && stripId<fLEDRefs) { | |
642 | if (gain == 0) { | |
643 | for ( i=0; i<nPed; i++) { | |
644 | ((TProfile*)fPedestalLEDRefLowGain[arrayPos])->Fill(stripId, pedSamples[i]); | |
645 | } | |
646 | } | |
647 | else { | |
648 | for ( i=0; i<nPed; i++) { | |
649 | ((TProfile*)fPedestalLEDRefHighGain[arrayPos])->Fill(stripId, pedSamples[i]); | |
650 | } | |
651 | } | |
652 | } | |
653 | } | |
419341ea | 654 | |
56613d93 | 655 | } // nsamples>0 check, some data found for this channel; not only trailer/header |
32cd4c24 | 656 | }// end while over channel |
657 | }//end while over DDL's, of input stream | |
658 | ||
32cd4c24 | 659 | |
356c3e0c | 660 | return kTRUE; |
661 | } | |
662 | ||
663 | //_____________________________________________________________________ | |
664 | Bool_t AliCaloCalibPedestal::SaveHistograms(TString fileName, Bool_t saveEmptyHistos) | |
665 | { | |
666 | //Saves all the histograms (or profiles, to be accurate) to the designated file | |
23ca956b | 667 | ValidateProfiles(); // make sure histos/profiles exist |
356c3e0c | 668 | TFile destFile(fileName, "recreate"); |
669 | ||
670 | if (destFile.IsZombie()) { | |
671 | return kFALSE; | |
672 | } | |
673 | ||
674 | destFile.cd(); | |
675 | ||
676 | for (int i = 0; i < fModules; i++) { | |
677 | if( ((TProfile2D *)fPeakMinusPedLowGain[i])->GetEntries() || saveEmptyHistos) { | |
678 | fPeakMinusPedLowGain[i]->Write(); | |
679 | } | |
680 | if( ((TProfile2D *)fPeakMinusPedHighGain[i])->GetEntries() || saveEmptyHistos) { | |
681 | fPeakMinusPedHighGain[i]->Write(); | |
682 | } | |
683 | if( ((TProfile2D *)fPedestalLowGain[i])->GetEntries() || saveEmptyHistos) { | |
684 | fPedestalLowGain[i]->Write(); | |
685 | } | |
686 | if( ((TProfile2D *)fPedestalHighGain[i])->GetEntries() || saveEmptyHistos) { | |
687 | fPedestalHighGain[i]->Write(); | |
688 | } | |
29f94584 | 689 | if( ((TProfile *)fPedestalLEDRefLowGain[i])->GetEntries() || saveEmptyHistos) { |
690 | fPedestalLEDRefLowGain[i]->Write(); | |
18db89b7 | 691 | } |
29f94584 | 692 | if( ((TProfile *)fPedestalLEDRefHighGain[i])->GetEntries() || saveEmptyHistos) { |
693 | fPedestalLEDRefHighGain[i]->Write(); | |
18db89b7 | 694 | } |
59ed788d | 695 | if( ((TH2F *)fPeakMinusPedHighGainHisto[i])->GetEntries() || saveEmptyHistos) { |
696 | fPeakMinusPedHighGainHisto[i]->Write(); | |
697 | } | |
698 | ||
356c3e0c | 699 | } |
700 | ||
701 | destFile.Close(); | |
702 | ||
703 | return kTRUE; | |
704 | } | |
705 | ||
706 | //_____________________________________________________________________ | |
707 | Bool_t AliCaloCalibPedestal::LoadReferenceCalib(TString fileName, TString objectName) | |
708 | { | |
709 | ||
710 | //Make sure that the histograms created when loading the object are not destroyed as the file object is destroyed | |
711 | TH1::AddDirectory(kFALSE); | |
712 | ||
713 | TFile *sourceFile = new TFile(fileName); | |
714 | if (sourceFile->IsZombie()) { | |
715 | return kFALSE;//We couldn't load the reference | |
716 | } | |
717 | ||
718 | if (fReference) delete fReference;//Delete the reference object, if it already exists | |
719 | fReference = 0; | |
720 | ||
721 | fReference = (AliCaloCalibPedestal*)sourceFile->Get(objectName); | |
722 | ||
723 | if (!fReference || !(fReference->InheritsFrom(AliCaloCalibPedestal::Class())) || (fReference->GetDetectorType() != fDetType)) { | |
724 | if (fReference) delete fReference;//Delete the object, in case we had an object of the wrong type | |
725 | fReference = 0; | |
726 | return kFALSE; | |
727 | } | |
728 | ||
729 | delete sourceFile; | |
29f94584 | 730 | |
356c3e0c | 731 | //Reset the histogram ownership behaviour. NOTE: a better workaround would be good, since this may accidentally set AddDirectory to true, even |
732 | //if we are called by someone who has set it to false... | |
733 | TH1::AddDirectory(kTRUE); | |
734 | ||
735 | return kTRUE;//We succesfully loaded the object | |
736 | } | |
737 | ||
35eabcf4 | 738 | |
739 | //_____________________________________________________________________ | |
740 | Bool_t AliCaloCalibPedestal::SetReference(AliCaloCalibPedestal *ref) | |
741 | { | |
742 | if (fReference) delete fReference;//Delete the reference object, if it already exists | |
743 | fReference = 0; | |
744 | ||
745 | fReference = ref; | |
746 | ||
747 | if (!fReference || (fReference->GetDetectorType() != fDetType)) { | |
748 | if (fReference) delete fReference;//Delete the object, in case we had an object of the wrong type | |
749 | fReference = 0; | |
750 | return kFALSE; | |
751 | } | |
752 | ||
753 | return kTRUE;//We succesfully loaded the object | |
754 | } | |
755 | ||
356c3e0c | 756 | //_____________________________________________________________________ |
757 | void AliCaloCalibPedestal::ValidateComparisonProfiles() | |
758 | { | |
a235e2bc | 759 | //Make sure the comparison histos exist |
356c3e0c | 760 | if (!fPedestalLowGainDiff.IsEmpty()) return; //The profiles already exist. We just check one, because they're all created at |
761 | //the same time | |
762 | ||
763 | ||
764 | //Then, loop for the requested number of modules | |
765 | TString title, name; | |
766 | for (int i = 0; i < fModules; i++) { | |
767 | //Pedestals, low gain | |
768 | name = "hPedlowgainDiff"; | |
769 | name += i; | |
770 | title = "Pedestals difference, low gain, module "; | |
771 | title += i; | |
772 | fPedestalLowGainDiff.Add(new TProfile2D(name, title, | |
773 | fColumns, 0.0, fColumns, | |
18db89b7 | 774 | fRows, fRowMin, fRowMax,"s")); |
356c3e0c | 775 | |
776 | //Pedestals, high gain | |
777 | name = "hPedhighgainDiff"; | |
778 | name += i; | |
779 | title = "Pedestals difference, high gain, module "; | |
780 | title += i; | |
781 | fPedestalHighGainDiff.Add(new TProfile2D(name, title, | |
782 | fColumns, 0.0, fColumns, | |
18db89b7 | 783 | fRows, fRowMin, fRowMax,"s")); |
784 | ||
29f94584 | 785 | //LED Ref/Mon pedestals, low gain |
786 | name = "hPedestalLEDReflowgainDiff"; | |
787 | name += i; | |
788 | title = "Pedestal difference LEDRef, low gain, module "; | |
789 | title += i; | |
790 | fPedestalLEDRefLowGainDiff.Add(new TProfile(name, title, | |
791 | fLEDRefs, 0.0, fLEDRefs, "s")); | |
792 | ||
793 | //LED Ref/Mon pedestals, high gain | |
794 | name = "hPedestalLEDRefhighgainDiff"; | |
795 | name += i; | |
796 | title = "Pedestal difference LEDRef, high gain, module "; | |
797 | title += i; | |
798 | fPedestalLEDRefHighGainDiff.Add(new TProfile(name, title, | |
799 | fLEDRefs, 0.0, fLEDRefs, "s")); | |
800 | ||
356c3e0c | 801 | //Peak-Pedestals, high gain |
802 | name = "hPeakMinusPedhighgainDiff"; | |
803 | name += i; | |
804 | title = "Peak-Pedestal difference, high gain, module "; | |
805 | title += i; | |
806 | fPeakMinusPedHighGainDiff.Add(new TProfile2D(name, title, | |
807 | fColumns, 0.0, fColumns, | |
18db89b7 | 808 | fRows, fRowMin, fRowMax,"s")); |
29f94584 | 809 | |
810 | //Peak-Pedestals, low gain | |
811 | name = "hPeakMinusPedlowgainDiff"; | |
812 | name += i; | |
813 | title = "Peak-Pedestal difference, low gain, module "; | |
814 | title += i; | |
815 | fPeakMinusPedLowGainDiff.Add(new TProfile2D(name, title, | |
816 | fColumns, 0.0, fColumns, | |
817 | fRows, fRowMin, fRowMax,"s")); | |
356c3e0c | 818 | |
819 | //Pedestals, low gain | |
820 | name = "hPedlowgainRatio"; | |
821 | name += i; | |
822 | title = "Pedestals ratio, low gain, module "; | |
823 | title += i; | |
824 | fPedestalLowGainRatio.Add(new TProfile2D(name, title, | |
825 | fColumns, 0.0, fColumns, | |
18db89b7 | 826 | fRows, fRowMin, fRowMax,"s")); |
356c3e0c | 827 | |
828 | //Pedestals, high gain | |
829 | name = "hPedhighgainRatio"; | |
830 | name += i; | |
831 | title = "Pedestals ratio, high gain, module "; | |
832 | title += i; | |
833 | fPedestalHighGainRatio.Add(new TProfile2D(name, title, | |
834 | fColumns, 0.0, fColumns, | |
18db89b7 | 835 | fRows, fRowMin, fRowMax,"s")); |
29f94584 | 836 | |
837 | //LED Ref/Mon pedestals, low gain | |
35eabcf4 | 838 | name = "hPedestalLEDReflowgainRatio"; |
29f94584 | 839 | name += i; |
840 | title = "Pedestal ratio LEDRef, low gain, module "; | |
841 | title += i; | |
842 | fPedestalLEDRefLowGainRatio.Add(new TProfile(name, title, | |
843 | fLEDRefs, 0.0, fLEDRefs, "s")); | |
844 | ||
845 | //LED Ref/Mon pedestals, high gain | |
846 | name = "hPedestalLEDRefhighgainRatio"; | |
847 | name += i; | |
848 | title = "Pedestal ratio LEDRef, high gain, module "; | |
849 | title += i; | |
850 | fPedestalLEDRefHighGainRatio.Add(new TProfile(name, title, | |
851 | fLEDRefs, 0.0, fLEDRefs, "s")); | |
356c3e0c | 852 | |
853 | //Peak-Pedestals, low gain | |
854 | name = "hPeakMinusPedlowgainRatio"; | |
855 | name += i; | |
856 | title = "Peak-Pedestal ratio, low gain, module "; | |
857 | title += i; | |
858 | fPeakMinusPedLowGainRatio.Add(new TProfile2D(name, title, | |
859 | fColumns, 0.0, fColumns, | |
18db89b7 | 860 | fRows, fRowMin, fRowMax,"s")); |
356c3e0c | 861 | |
862 | //Peak-Pedestals, high gain | |
863 | name = "hPeakMinusPedhighgainRatio"; | |
864 | name += i; | |
865 | title = "Peak-Pedestal ratio, high gain, module "; | |
866 | title += i; | |
867 | fPeakMinusPedHighGainRatio.Add(new TProfile2D(name, title, | |
868 | fColumns, 0.0, fColumns, | |
18db89b7 | 869 | fRows, fRowMin, fRowMax,"s")); |
356c3e0c | 870 | |
871 | }//end for nModules create the histograms | |
872 | } | |
873 | ||
874 | //_____________________________________________________________________ | |
875 | void AliCaloCalibPedestal::ComputeDiffAndRatio() | |
876 | { | |
a235e2bc | 877 | // calculate differences and ratios relative to a reference |
23ca956b | 878 | ValidateProfiles(); // make sure histos/profiles exist |
356c3e0c | 879 | ValidateComparisonProfiles();//Make sure the comparison histos exist |
880 | ||
881 | if (!fReference) { | |
882 | return;//Return if the reference object isn't loaded | |
883 | } | |
884 | ||
29f94584 | 885 | int bin = 0; |
886 | double diff = 0; | |
887 | double ratio = 1; | |
356c3e0c | 888 | for (int i = 0; i < fModules; i++) { |
356c3e0c | 889 | //For computing the difference, we cannot simply do TProfile2D->Add(), because that subtracts the sum of all entries, |
890 | //which means that the mean of the new profile will not be the difference of the means. So do it by hand: | |
29f94584 | 891 | for (int j = 0; j < fColumns; j++) { |
892 | for (int k = 0; k < fRows; k++) { | |
893 | bin = ((TProfile2D*)fPeakMinusPedHighGainDiff[i])->GetBin(j+1, k+1);//Note that we assume here that all histos have the same structure... | |
894 | ||
895 | if (fReference->GetPeakProfileHighGain(i)->GetBinContent(bin) > 0) { | |
896 | diff = GetPeakProfileHighGain(i)->GetBinContent(bin) - fReference->GetPeakProfileHighGain(i)->GetBinContent(bin); | |
897 | ((TProfile2D*)fPeakMinusPedHighGainDiff[i])->SetBinContent(bin, diff); | |
898 | ((TProfile2D*)fPeakMinusPedHighGainDiff[i])->SetBinEntries(bin, 1); | |
899 | ratio = GetPeakProfileHighGain(i)->GetBinContent(bin) / fReference->GetPeakProfileHighGain(i)->GetBinContent(bin); | |
900 | ((TProfile2D*)fPeakMinusPedHighGainRatio[i])->SetBinContent(bin, ratio); | |
901 | ((TProfile2D*)fPeakMinusPedHighGainRatio[i])->SetBinEntries(bin, 1); | |
902 | } | |
903 | ||
904 | if (fReference->GetPeakProfileLowGain(i)->GetBinContent(bin) > 0) { | |
905 | diff = GetPeakProfileLowGain(i)->GetBinContent(bin) - fReference->GetPeakProfileLowGain(i)->GetBinContent(bin); | |
906 | ((TProfile2D*)fPeakMinusPedLowGainDiff[i])->SetBinContent(bin, diff); | |
907 | ((TProfile2D*)fPeakMinusPedLowGainDiff[i])->SetBinEntries(bin, 1); | |
908 | ratio = GetPeakProfileLowGain(i)->GetBinContent(bin) / fReference->GetPeakProfileLowGain(i)->GetBinContent(bin); | |
909 | ((TProfile2D*)fPeakMinusPedLowGainRatio[i])->SetBinContent(bin, ratio); | |
910 | ((TProfile2D*)fPeakMinusPedLowGainRatio[i])->SetBinEntries(bin, 1); | |
911 | } | |
912 | ||
913 | if (fReference->GetPedProfileHighGain(i)->GetBinContent(bin) > 0) { | |
914 | diff = GetPedProfileHighGain(i)->GetBinContent(bin) - fReference->GetPedProfileHighGain(i)->GetBinContent(bin); | |
915 | ((TProfile2D*)fPedestalHighGainDiff[i])->SetBinContent(bin, diff); | |
916 | ((TProfile2D*)fPedestalHighGainDiff[i])->SetBinEntries(bin, 1); | |
917 | ratio = GetPedProfileHighGain(i)->GetBinContent(bin) / fReference->GetPedProfileHighGain(i)->GetBinContent(bin); | |
918 | ((TProfile2D*)fPedestalHighGainRatio[i])->SetBinContent(bin, ratio); | |
919 | ((TProfile2D*)fPedestalHighGainRatio[i])->SetBinEntries(bin, 1); | |
920 | } | |
921 | ||
922 | if (fReference->GetPedProfileLowGain(i)->GetBinContent(bin) > 0) { | |
923 | diff = GetPedProfileLowGain(i)->GetBinContent(bin) - fReference->GetPedProfileLowGain(i)->GetBinContent(bin); | |
924 | ((TProfile2D*)fPedestalLowGainDiff[i])->SetBinContent(bin, diff); | |
925 | ((TProfile2D*)fPedestalLowGainDiff[i])->SetBinEntries(bin, 1); | |
926 | ratio = GetPedProfileLowGain(i)->GetBinContent(bin) / fReference->GetPedProfileLowGain(i)->GetBinContent(bin); | |
927 | ((TProfile2D*)fPedestalLowGainRatio[i])->SetBinContent(bin, ratio); | |
928 | ((TProfile2D*)fPedestalLowGainRatio[i])->SetBinEntries(bin, 1); | |
929 | } | |
930 | ||
356c3e0c | 931 | } // rows |
932 | } // columns | |
29f94584 | 933 | |
934 | // same for LED Ref/Mon channels | |
935 | for (int j = 0; j <= fLEDRefs; j++) { | |
936 | bin = j+1;//Note that we assume here that all histos have the same structure... | |
937 | ||
938 | if (fReference->GetPedLEDRefProfileHighGain(i)->GetBinContent(bin) > 0) { | |
939 | diff = GetPedLEDRefProfileHighGain(i)->GetBinContent(bin) - fReference->GetPedLEDRefProfileHighGain(i)->GetBinContent(bin); | |
940 | ((TProfile*)fPedestalLEDRefHighGainDiff[i])->SetBinContent(bin, diff); | |
941 | ((TProfile*)fPedestalLEDRefHighGainDiff[i])->SetBinEntries(bin, 1); | |
942 | ratio = GetPedLEDRefProfileHighGain(i)->GetBinContent(bin) / fReference->GetPedLEDRefProfileHighGain(i)->GetBinContent(bin); | |
943 | ((TProfile*)fPedestalLEDRefHighGainRatio[i])->SetBinContent(bin, ratio); | |
944 | ((TProfile*)fPedestalLEDRefHighGainRatio[i])->SetBinEntries(bin, 1); | |
945 | } | |
946 | ||
947 | if (fReference->GetPedLEDRefProfileLowGain(i)->GetBinContent(bin) > 0) { | |
948 | diff = GetPedLEDRefProfileLowGain(i)->GetBinContent(bin) - fReference->GetPedLEDRefProfileLowGain(i)->GetBinContent(bin); | |
949 | ((TProfile*)fPedestalLEDRefLowGainDiff[i])->SetBinContent(bin, diff); | |
950 | ((TProfile*)fPedestalLEDRefLowGainDiff[i])->SetBinEntries(bin, 1); | |
951 | ratio = GetPedLEDRefProfileLowGain(i)->GetBinContent(bin) / fReference->GetPedLEDRefProfileLowGain(i)->GetBinContent(bin); | |
952 | ((TProfile*)fPedestalLEDRefLowGainRatio[i])->SetBinContent(bin, ratio); | |
953 | ((TProfile*)fPedestalLEDRefLowGainRatio[i])->SetBinEntries(bin, 1); | |
954 | } | |
955 | ||
956 | } | |
957 | ||
356c3e0c | 958 | } // modules |
959 | ||
960 | } | |
961 | ||
962 | //_____________________________________________________________________ | |
59ed788d | 963 | void AliCaloCalibPedestal::ComputeHotAndWarningTowers(const char * hotMapFile) |
964 | { // look for hot/noisy towers | |
23ca956b | 965 | ValidateProfiles(); // make sure histos/profiles exist |
59ed788d | 966 | ofstream * fout = 0; |
967 | char name[512];//Quite a long temp buffer, just in case the filename includes a path | |
968 | ||
969 | if (hotMapFile) { | |
970 | snprintf(name, 512, "%s.txt", hotMapFile); | |
971 | fout = new ofstream(name); | |
972 | if (!fout->is_open()) { | |
973 | delete fout; | |
974 | fout = 0;//Set the pointer to empty if the file was not opened | |
975 | } | |
976 | } | |
977 | ||
978 | for(int i = 0; i < fModules; i++){ | |
979 | ||
980 | //first we compute the peak-pedestal distribution for each supermodule... | |
981 | if( GetPeakHighGainHisto(i)->GetEntries() > 0 ) { | |
982 | double min = GetPeakProfileHighGain(i)->GetBinContent(GetPeakProfileHighGain(i)->GetMinimumBin()); | |
983 | double max = GetPeakProfileHighGain(i)->GetBinContent(GetPeakProfileHighGain(i)->GetMaximumBin()); | |
984 | TH1D *hPeakFit = new TH1D(Form("hFit_%d", i), Form("hFit_%d", i), (int)((max-min)*10), min-1, max+1); | |
985 | ||
986 | for (int j = 1; j <= fColumns; j++) { | |
987 | for (int k = 1; k <= fRows; k++) { | |
988 | hPeakFit->Fill(GetPeakProfileHighGain(i)->GetBinContent(j, k)); | |
989 | } | |
990 | } | |
991 | ||
c490d8e5 | 992 | //...and then we try to fit it |
993 | double mean = hPeakFit->GetMean(); | |
994 | double sigma = hPeakFit->GetRMS(); | |
995 | try { | |
996 | hPeakFit->Fit("gaus", "OQ", "", mean - 3*sigma, mean + 3*sigma); | |
997 | mean = hPeakFit->GetFunction("gaus")->GetParameter(1); | |
998 | sigma = hPeakFit->GetFunction("gaus")->GetParameter(2); | |
999 | } | |
1000 | catch (const std::exception & e) { | |
1001 | printf("AliCaloCalibPedestal: TH1D PeakFit exception %s", e.what()); | |
1002 | } | |
59ed788d | 1003 | //hPeakFit->Draw(); |
59ed788d | 1004 | |
1005 | delete hPeakFit; | |
1006 | ||
1007 | //Then we look for warm/hot towers | |
1008 | TH2F * hPeak2D = GetPeakHighGainHisto(i); | |
1009 | hPeak2D->GetYaxis()->SetRangeUser( fWarningThreshold, hPeak2D->GetYaxis()->GetBinUpEdge(hPeak2D->GetNbinsY()) ); | |
1010 | ||
1011 | int idx = 0 ; | |
1012 | int warnCounter = 0; | |
1013 | for (int j = 1; j <= fColumns; j++) { | |
1014 | for (int k = 1; k <= fRows; k++) { | |
1015 | //we start looking for warm/warning towers... | |
1016 | // histogram x-axis index | |
1017 | idx = k-1 + fRows*(j-1); // this is what is used in the Fill call | |
1018 | hPeak2D->GetXaxis()->SetRangeUser(idx, idx); | |
1019 | warnCounter = (int) hPeak2D->Integral(); | |
1020 | if(warnCounter > fNEvents * fWarningFraction) { | |
1021 | ((TH2D*)fDeadMap[i])->SetBinContent(j, k, kWarning); | |
1022 | /* printf("mod %d col %d row %d warnCounter %d - status %d\n", | |
1023 | i, j-1, k-1, warnCounter, (int) (kWarning)); */ | |
1024 | } | |
1025 | //...then we look for hot ones (towers whose values are greater than mean + X*sigma) | |
1026 | if(GetPeakProfileHighGain(i)->GetBinContent(j, k) > mean + fHotSigma*sigma ) { | |
1027 | ((TH2D*)fDeadMap[i])->SetBinContent(j, k, kHot); | |
1028 | /* printf("mod %d col %d row %d binc %d - status %d\n", | |
1029 | i, j-1, k-1, (int)(GetPeakProfileHighGain(i)->GetBinContent(j, k)), (int) (kHot)); */ | |
1030 | } | |
1031 | ||
1032 | //Write the status to the hot/warm map file, if the file is open. | |
1033 | // module - column - row - status (1=dead, 2= warm/warning , 3 = hot, see .h file enum) | |
1034 | if (fout && ((TH2D*)fDeadMap[i])->GetBinContent(j, k) > 1) { | |
1035 | ||
1036 | (*fout) << i << " " | |
1037 | << (j - 1) << " " | |
1038 | << (k - 1) << " " | |
1039 | << ((TH2D*)fDeadMap[i])->GetBinContent(j, k) << endl; } | |
1040 | ||
1041 | } | |
1042 | } | |
1043 | ||
1044 | } | |
1045 | } | |
1046 | return; | |
1047 | } | |
1048 | ||
1049 | //_____________________________________________________________________ | |
1050 | void AliCaloCalibPedestal::ComputeDeadTowers(const char * deadMapFile) | |
a235e2bc | 1051 | { |
23ca956b | 1052 | ValidateProfiles(); // make sure histos/profiles exist |
a235e2bc | 1053 | //Computes the number of dead towers etc etc into memory, after this you can call the GetDead... -functions |
356c3e0c | 1054 | int countTot = 0; |
1055 | int countNew = 0; | |
1056 | int countRes = 0; | |
1057 | ofstream * fout = 0; | |
1058 | ofstream * diff = 0; | |
1059 | char name[512];//Quite a long temp buffer, just in case the filename includes a path | |
1060 | ||
1061 | if (deadMapFile) { | |
1062 | snprintf(name, 512, "%s.txt", deadMapFile); | |
1063 | fout = new ofstream(name); | |
1064 | snprintf(name, 512, "%sdiff.txt", deadMapFile); | |
1065 | diff = new ofstream(name); | |
1066 | if (!fout->is_open()) { | |
1067 | delete fout; | |
1068 | fout = 0;//Set the pointer to empty if the file was not opened | |
1069 | } | |
1070 | if (!diff->is_open()) { | |
1071 | delete diff; | |
b48d1356 | 1072 | diff = 0;//Set the pointer to empty if the file was not opened |
356c3e0c | 1073 | } |
1074 | } | |
1075 | ||
1076 | for (int i = 0; i < fModules; i++) { | |
1077 | if (GetPeakProfileHighGain(i)->GetEntries() > 0) { //don't care about empty histos | |
1078 | for (int j = 1; j <= fColumns; j++) { | |
1079 | for (int k = 1; k <= fRows; k++) { | |
1080 | ||
59ed788d | 1081 | if (GetPeakProfileHighGain(i)->GetBinContent(j, k) < fDeadThreshold) {//It's dead |
356c3e0c | 1082 | countTot++;//One more dead total |
1083 | if (fout) { | |
1084 | (*fout) << i << " " | |
59ed788d | 1085 | << (j - 1) << " " |
1086 | << (k - 1) << " " | |
356c3e0c | 1087 | << "1" << " " |
1088 | << "0" << endl;//Write the status to the deadmap file, if the file is open. | |
1089 | } | |
1090 | ||
59ed788d | 1091 | if (fReference && fReference->GetPeakProfileHighGain(i)->GetBinContent(j, k) >= fDeadThreshold) { |
356c3e0c | 1092 | ((TH2D*)fDeadMap[i])->SetBinContent(j, k, kRecentlyDeceased); |
1093 | countNew++;//This tower wasn't dead before! | |
1094 | if (diff) { | |
1095 | ( *diff) << i << " " | |
356c3e0c | 1096 | << (j - 1) << " " |
59ed788d | 1097 | << (k - 1) << " " |
356c3e0c | 1098 | << "1" << " " |
1099 | << "0" << endl;//Write the status to the deadmap difference file, if the file is open. | |
1100 | } | |
1101 | } | |
1102 | else { | |
1103 | ((TH2D*)fDeadMap[i])->SetBinContent(j, k, kDead);//This has been dead before. Nothing new | |
1104 | } | |
1105 | } | |
1106 | else { //It's ALIVE!! | |
1107 | //Don't bother with writing the live ones. | |
59ed788d | 1108 | if (fReference && fReference->GetPeakProfileHighGain(i)->GetBinContent(j, k) < fDeadThreshold) { |
356c3e0c | 1109 | ((TH2D*)fDeadMap[i])->SetBinContent(j, k, kResurrected); |
1110 | countRes++; //This tower was dead before => it's a miracle! :P | |
1111 | if (diff) { | |
1112 | (*diff) << i << " " | |
356c3e0c | 1113 | << (j - 1) << " " |
59ed788d | 1114 | << (k - 1) << " " |
356c3e0c | 1115 | << "1" << " " |
1116 | << "1" << endl;//Write the status to the deadmap difference file, if the file is open. | |
1117 | } | |
1118 | } | |
1119 | else { | |
1120 | ((TH2D*)fDeadMap[i])->SetBinContent(j, k, kAlive); | |
1121 | } | |
1122 | } | |
1123 | ||
1124 | }//end for k/rows | |
1125 | }//end for j/columns | |
1126 | }//end if GetEntries >= 0 | |
1127 | ||
1128 | }//end for modules | |
1129 | ||
1130 | if (fout) { | |
1131 | fout->close(); | |
1132 | delete fout; | |
1133 | } | |
1134 | ||
1135 | fDeadTowers = countTot; | |
1136 | fNewDeadTowers = countNew; | |
1137 | fResurrectedTowers = countRes; | |
1138 | } | |
1139 | ||
40164976 | 1140 | //_____________________________________________________________________ |
1141 | Bool_t AliCaloCalibPedestal::IsBadChannel(int imod, int icol, int irow) const | |
1142 | { | |
23ca956b | 1143 | // Check if status info histo exists |
1144 | if (!fDeadMap[imod]) { | |
1145 | return kFALSE; | |
1146 | } | |
1147 | ||
59ed788d | 1148 | //Check if channel is dead or hot. |
1149 | Int_t status = (Int_t) ( ((TH2D*)fDeadMap[imod])->GetBinContent(icol,irow) ); | |
1150 | if(status == kAlive) | |
1151 | return kFALSE; | |
1152 | else | |
1153 | return kTRUE; | |
1154 | ||
40164976 | 1155 | } |
1156 | ||
1157 | //_____________________________________________________________________ | |
1158 | void AliCaloCalibPedestal::SetChannelStatus(int imod, int icol, int irow, int status) | |
1159 | { | |
23ca956b | 1160 | ValidateProfiles(); // make sure histos/profiles exist |
59ed788d | 1161 | //Set status of channel dead, hot, alive ... |
1162 | ((TH2D*)fDeadMap[imod])->SetBinContent(icol, irow, status); | |
40164976 | 1163 | } |