170c35f1 |
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 | /* |
3a0f6479 |
19 | example: fill pedestal with Gaussian noise |
170c35f1 |
20 | AliTRDCalibPadStatus ped; |
21 | ped.TestEvent(numberofevent); |
22 | // Method without histo |
23 | ////////////////////////// |
24 | ped.Analyse(); |
25 | //Create the histo of the AliTRDCalROC |
26 | TH2F * histo2dm = ped.GetCalRocMean(0,kFALSE)->MakeHisto2D(); |
27 | histo2dm->Scale(10.0); |
28 | TH1F * histo1dm = ped.GetCalRocMean(0,kFALSE)->MakeHisto1D(); |
29 | histo1dm->Scale(10.0); |
30 | TH2F * histo2ds = ped.GetCalRocSquares(0,kFALSE)->MakeHisto2D(); |
31 | histo2ds->Scale(10.0); |
32 | TH1F * histo1ds = ped.GetCalRocSquares(0,kFALSE)->MakeHisto1D(); |
33 | histo1ds->Scale(10.0) |
34 | //Draw output; |
35 | TCanvas* c1 = new TCanvas; |
36 | c1->Divide(2,2); |
37 | c1->cd(1); |
38 | histo2dm->Draw("colz"); |
39 | c1->cd(2); |
40 | histo1dm->Draw(); |
41 | c1->cd(3); |
42 | histo2ds->Draw("colz"); |
43 | c1->cd(4); |
44 | histo1ds->Draw(); |
45 | // Method with histo |
46 | ///////////////////////// |
47 | ped.AnalyseHisto(); |
48 | //Take the histo |
49 | TH1F * histo = ped.GetHisto(31); |
50 | histo->SetEntries(1); |
51 | histo->Draw(); |
52 | |
53 | */ |
54 | |
55 | //Root includes |
56 | #include <TObjArray.h> |
57 | #include <TH1F.h> |
58 | #include <TH2F.h> |
59 | #include <TString.h> |
60 | #include <TMath.h> |
61 | #include <TF1.h> |
62 | #include <TRandom.h> |
63 | #include <TDirectory.h> |
64 | #include <TFile.h> |
3a0f6479 |
65 | #include <TTreeStream.h> |
f162af62 |
66 | |
170c35f1 |
67 | //AliRoot includes |
3a0f6479 |
68 | #include <AliMathBase.h> |
170c35f1 |
69 | #include "AliRawReader.h" |
70 | #include "AliRawReaderRoot.h" |
71 | #include "AliRawReaderDate.h" |
f162af62 |
72 | |
3a0f6479 |
73 | //header file |
74 | #include "AliTRDCalibPadStatus.h" |
289cc637 |
75 | #include "AliTRDRawStreamV2.h" |
f162af62 |
76 | #include "AliTRDarrayF.h" |
77 | #include "AliTRDgeometry.h" |
3a0f6479 |
78 | #include "AliTRDCommonParam.h" |
170c35f1 |
79 | #include "./Cal/AliTRDCalROC.h" |
80 | #include "./Cal/AliTRDCalPadStatus.h" |
289cc637 |
81 | #include "./Cal/AliTRDCalDet.h" |
82 | #include "./Cal/AliTRDCalPad.h" |
170c35f1 |
83 | #include "./Cal/AliTRDCalSingleChamberStatus.h" |
170c35f1 |
84 | |
85 | #ifdef ALI_DATE |
86 | #include "event.h" |
87 | #endif |
88 | |
170c35f1 |
89 | ClassImp(AliTRDCalibPadStatus) /*FOLD00*/ |
90 | |
91 | //_____________________________________________________________________ |
92 | AliTRDCalibPadStatus::AliTRDCalibPadStatus() : /*FOLD00*/ |
93 | TObject(), |
f162af62 |
94 | fGeo(0), |
170c35f1 |
95 | fAdcMin(0), |
96 | fAdcMax(20), |
97 | fDetector(-1), |
cf46274d |
98 | fNumberOfTimeBins(0), |
170c35f1 |
99 | fCalArrayEntries(540), |
100 | fCalArrayMean(540), |
101 | fCalArraySquares(540), |
102 | fCalRocArrayMean(540), |
103 | fCalRocArrayRMS(540), |
104 | fHistoArray(540), |
105 | fCalEntries(0x0), |
106 | fCalMean(0x0), |
107 | fCalSquares(0x0) |
108 | { |
109 | // |
110 | // default constructor |
111 | // |
f162af62 |
112 | |
113 | fGeo = new AliTRDgeometry(); |
114 | |
170c35f1 |
115 | } |
116 | |
117 | //_____________________________________________________________________ |
118 | AliTRDCalibPadStatus::AliTRDCalibPadStatus(const AliTRDCalibPadStatus &ped) : /*FOLD00*/ |
119 | TObject(ped), |
f162af62 |
120 | fGeo(0), |
170c35f1 |
121 | fAdcMin(ped.GetAdcMin()), |
122 | fAdcMax(ped.GetAdcMax()), |
123 | fDetector(ped.fDetector), |
cf46274d |
124 | fNumberOfTimeBins(ped.fNumberOfTimeBins), |
170c35f1 |
125 | fCalArrayEntries(540), |
126 | fCalArrayMean(540), |
127 | fCalArraySquares(540), |
128 | fCalRocArrayMean(540), |
129 | fCalRocArrayRMS(540), |
130 | fHistoArray(540), |
131 | fCalEntries(0x0), |
132 | fCalMean(0x0), |
133 | fCalSquares(0x0) |
134 | { |
135 | // |
136 | // copy constructor |
137 | // |
138 | for (Int_t idet = 0; idet < 540; idet++){ |
139 | const AliTRDarrayF *calEntries = (AliTRDarrayF*)ped.fCalArrayEntries.UncheckedAt(idet); |
140 | const AliTRDarrayF *calMean = (AliTRDarrayF*)ped.fCalArrayMean.UncheckedAt(idet); |
141 | const AliTRDarrayF *calSquares = (AliTRDarrayF*)ped.fCalArraySquares.UncheckedAt(idet); |
142 | const AliTRDCalROC *calRocMean = (AliTRDCalROC*)ped.fCalRocArrayMean.UncheckedAt(idet); |
143 | const AliTRDCalROC *calRocRMS = (AliTRDCalROC*)ped.fCalRocArrayRMS.UncheckedAt(idet); |
144 | const TH2F *hped = (TH2F*)ped.fHistoArray.UncheckedAt(idet); |
145 | |
146 | if ( calEntries != 0x0 ) fCalArrayEntries.AddAt(new AliTRDarrayF(*calEntries), idet); |
147 | if ( calMean != 0x0 ) fCalArrayMean.AddAt(new AliTRDarrayF(*calMean), idet); |
148 | if ( calSquares != 0x0 ) fCalArraySquares.AddAt(new AliTRDarrayF(*calSquares), idet); |
149 | if ( calRocMean != 0x0 ) fCalRocArrayMean.AddAt(new AliTRDCalROC(*calRocMean), idet); |
150 | if ( calRocRMS != 0x0 ) fCalRocArrayRMS.AddAt(new AliTRDCalROC(*calRocRMS), idet); |
151 | |
152 | if ( hped != 0x0 ){ |
153 | TH2F *hNew = new TH2F(*hped); |
154 | hNew->SetDirectory(0); |
155 | fHistoArray.AddAt(hNew,idet); |
156 | } |
157 | |
158 | } |
f162af62 |
159 | if (fGeo) { |
160 | delete fGeo; |
161 | } |
162 | fGeo = new AliTRDgeometry(); |
170c35f1 |
163 | } |
f162af62 |
164 | |
170c35f1 |
165 | //_____________________________________________________________________ |
166 | AliTRDCalibPadStatus& AliTRDCalibPadStatus::operator = (const AliTRDCalibPadStatus &source) |
167 | { |
168 | // |
169 | // assignment operator |
170 | // |
171 | if (&source == this) return *this; |
172 | new (this) AliTRDCalibPadStatus(source); |
173 | |
174 | return *this; |
175 | } |
f162af62 |
176 | |
170c35f1 |
177 | //_____________________________________________________________________ |
178 | AliTRDCalibPadStatus::~AliTRDCalibPadStatus() /*FOLD00*/ |
179 | { |
180 | // |
181 | // destructor |
182 | // |
f162af62 |
183 | if (fGeo) { |
184 | delete fGeo; |
185 | } |
170c35f1 |
186 | } |
f162af62 |
187 | |
170c35f1 |
188 | //_____________________________________________________________________ |
189 | Int_t AliTRDCalibPadStatus::Update(const Int_t icdet, /*FOLD00*/ |
190 | const Int_t icRow, |
191 | const Int_t icCol, |
192 | const Int_t csignal, |
193 | const Int_t crowMax) |
194 | { |
195 | // |
196 | // Signal filling methode |
197 | // |
198 | if ( (csignal>fAdcMax) || (csignal<fAdcMin) ) return 0; |
199 | |
200 | if(fDetector != icdet){ |
201 | fCalEntries = ((AliTRDarrayF *)GetCalEntries(icdet,kTRUE)); |
202 | fCalMean = ((AliTRDarrayF *)GetCalMean(icdet,kTRUE)); |
203 | fCalSquares = ((AliTRDarrayF *)GetCalSquares(icdet,kTRUE)); |
204 | } |
205 | |
206 | Float_t entries = fCalEntries->At(icRow+icCol*crowMax); |
207 | Float_t mean = fCalMean->At(icRow+icCol*crowMax); |
208 | Float_t squares = fCalSquares->At(icRow+icCol*crowMax); |
209 | |
210 | Float_t entriesn = entries+1.0; |
211 | fCalEntries->AddAt(entriesn,(icRow+icCol*crowMax)); |
212 | Float_t meann = (mean*entries+((Float_t)(csignal+0.5)))/entriesn; |
213 | fCalMean->AddAt(meann,icRow+icCol*crowMax); |
214 | Float_t squaresn = ((squares*entries)+(((Float_t)(csignal+0.5))*((Float_t)(csignal+0.5))))/entriesn; |
215 | fCalSquares->AddAt(squaresn,icRow+icCol*crowMax); |
216 | |
217 | //printf("icdet %d, icRow %d, icCol %d, csignal %d, crowMax %d\n",icdet,icRow,icCol,csignal,crowMax); |
218 | //printf("entries %f, mean %f, squares %f\n",entriesn,meann,squaresn); |
219 | |
220 | fDetector = icdet; |
221 | |
222 | return 0; |
223 | } |
3a0f6479 |
224 | |
170c35f1 |
225 | //_____________________________________________________________________ |
226 | Int_t AliTRDCalibPadStatus::UpdateHisto(const Int_t icdet, /*FOLD00*/ |
227 | const Int_t icRow, |
228 | const Int_t icCol, |
229 | const Int_t csignal, |
230 | const Int_t crowMax) |
231 | { |
232 | // |
233 | // Signal filling methode |
234 | // |
235 | Int_t nbchannel = icRow+icCol*crowMax; |
236 | |
237 | // fast filling methode. |
238 | // Attention: the entry counter of the histogram is not increased |
239 | // this means that e.g. the colz draw option gives an empty plot |
240 | Int_t bin = 0; |
241 | if ( !(((Int_t)csignal>fAdcMax ) || ((Int_t)csignal<fAdcMin)) ) |
242 | bin = (nbchannel+1)*(fAdcMax-fAdcMin+2)+((Int_t)csignal-fAdcMin+1); |
243 | |
244 | GetHisto(icdet,kTRUE)->GetArray()[bin]++; |
245 | |
246 | return 0; |
247 | } |
3a0f6479 |
248 | |
170c35f1 |
249 | //_____________________________________________________________________ |
289cc637 |
250 | Int_t AliTRDCalibPadStatus::ProcessEvent(AliTRDRawStreamV2 *rawStream, Bool_t nocheck) |
170c35f1 |
251 | { |
252 | // |
289cc637 |
253 | // Event Processing loop - AliTRDRawStreamV2 |
3a0f6479 |
254 | // 0 time bin problem or zero suppression |
255 | // 1 no input |
256 | // 2 input |
257 | // |
170c35f1 |
258 | |
3a0f6479 |
259 | Int_t withInput = 1; |
170c35f1 |
260 | |
cf46274d |
261 | if(!nocheck) { |
262 | while (rawStream->Next()) { |
263 | Int_t rawversion = rawStream->GetRawVersion(); // current raw version |
3a0f6479 |
264 | if(rawversion != 2) return 0; |
cf46274d |
265 | Int_t idetector = rawStream->GetDet(); // current detector |
266 | Int_t iRow = rawStream->GetRow(); // current row |
267 | Int_t iRowMax = rawStream->GetMaxRow(); // current rowmax |
268 | Int_t iCol = rawStream->GetCol(); // current col |
269 | Int_t iTimeBin = rawStream->GetTimeBin(); // current time bin |
270 | Int_t *signal = rawStream->GetSignals(); // current ADC signal |
271 | Int_t nbtimebin = rawStream->GetNumberOfTimeBins(); // number of time bins read from data |
272 | |
3a0f6479 |
273 | if((fDetector != -1) && (nbtimebin != fNumberOfTimeBins)) return 0; |
cf46274d |
274 | fNumberOfTimeBins = nbtimebin; |
275 | |
276 | Int_t fin = TMath::Min(nbtimebin,(iTimeBin+3)); |
277 | Int_t n = 0; |
278 | |
279 | for(Int_t k = iTimeBin; k < fin; k++){ |
280 | if(signal[n]>0) UpdateHisto(idetector,iRow,iCol,signal[n],iRowMax); |
281 | n++; |
282 | } |
283 | |
3a0f6479 |
284 | withInput = 2; |
cf46274d |
285 | } |
286 | } |
287 | else { |
288 | while (rawStream->Next()) { |
289 | Int_t idetector = rawStream->GetDet(); // current detector |
290 | Int_t iRow = rawStream->GetRow(); // current row |
291 | Int_t iRowMax = rawStream->GetMaxRow(); // current rowmax |
292 | Int_t iCol = rawStream->GetCol(); // current col |
293 | Int_t iTimeBin = rawStream->GetTimeBin(); // current time bin |
294 | Int_t *signal = rawStream->GetSignals(); // current ADC signal |
295 | Int_t nbtimebin = rawStream->GetNumberOfTimeBins(); // number of time bins read from data |
296 | |
297 | Int_t fin = TMath::Min(nbtimebin,(iTimeBin+3)); |
298 | Int_t n = 0; |
299 | |
300 | for(Int_t k = iTimeBin; k < fin; k++){ |
301 | if(signal[n]>0) UpdateHisto(idetector,iRow,iCol,signal[n],iRowMax); |
302 | n++; |
303 | } |
304 | |
3a0f6479 |
305 | withInput = 2; |
170c35f1 |
306 | } |
170c35f1 |
307 | } |
308 | |
309 | return withInput; |
310 | } |
3a0f6479 |
311 | |
170c35f1 |
312 | //_____________________________________________________________________ |
3a0f6479 |
313 | Int_t AliTRDCalibPadStatus::ProcessEvent(AliRawReader *rawReader, Bool_t nocheck) |
170c35f1 |
314 | { |
315 | // |
316 | // Event processing loop - AliRawReader |
317 | // |
318 | |
319 | |
289cc637 |
320 | AliTRDRawStreamV2 rawStream(rawReader); |
170c35f1 |
321 | |
322 | rawReader->Select("TRD"); |
323 | |
cf46274d |
324 | return ProcessEvent(&rawStream, nocheck); |
170c35f1 |
325 | } |
3a0f6479 |
326 | |
170c35f1 |
327 | //_________________________________________________________________________ |
3a0f6479 |
328 | Int_t AliTRDCalibPadStatus::ProcessEvent( |
170c35f1 |
329 | #ifdef ALI_DATE |
cf46274d |
330 | eventHeaderStruct *event, |
331 | Bool_t nocheck |
170c35f1 |
332 | #else |
cf46274d |
333 | eventHeaderStruct* /*event*/, |
334 | Bool_t /*nocheck*/ |
170c35f1 |
335 | |
336 | #endif |
cf46274d |
337 | ) |
170c35f1 |
338 | { |
339 | // |
340 | // process date event |
341 | // |
342 | #ifdef ALI_DATE |
343 | AliRawReader *rawReader = new AliRawReaderDate((void*)event); |
cf46274d |
344 | Bool_t result=ProcessEvent(rawReader, nocheck); |
170c35f1 |
345 | delete rawReader; |
346 | return result; |
347 | #else |
348 | Fatal("AliTRDCalibPadStatus", "this class was compiled without DATE"); |
349 | return 0; |
350 | #endif |
351 | |
352 | } |
3a0f6479 |
353 | |
170c35f1 |
354 | //_____________________________________________________________________ |
289cc637 |
355 | Bool_t AliTRDCalibPadStatus::TestEvent(Int_t nevent, Int_t sm) /*FOLD00*/ |
170c35f1 |
356 | { |
357 | // |
358 | // Test event loop |
359 | // fill one oroc and one iroc with random gaus |
360 | // |
361 | |
170c35f1 |
362 | gRandom->SetSeed(0); |
363 | |
289cc637 |
364 | for (Int_t ism=sm; ism<sm+1; ism++){ |
170c35f1 |
365 | for (Int_t ich=0; ich < 5; ich++){ |
366 | for (Int_t ipl=0; ipl < 6; ipl++){ |
f162af62 |
367 | for(Int_t irow = 0; irow < fGeo->GetRowMax(ipl,ich,ism); irow++){ |
368 | for(Int_t icol = 0; icol < fGeo->GetColMax(ipl); icol++){ |
170c35f1 |
369 | for (Int_t iTimeBin=0; iTimeBin<(30*nevent); iTimeBin++){ |
289cc637 |
370 | Int_t signal=(Int_t)(gRandom->Gaus(10.0,1.2)); |
f162af62 |
371 | if ( signal>0 )Update((ipl+ich*6+ism*6*5),irow,icol,signal,fGeo->GetRowMax(ipl,ich,ism)); |
170c35f1 |
372 | } |
373 | } |
374 | } |
375 | } |
376 | } |
377 | } |
378 | return kTRUE; |
379 | } |
3a0f6479 |
380 | |
170c35f1 |
381 | //_____________________________________________________________________ |
289cc637 |
382 | Bool_t AliTRDCalibPadStatus::TestEventHisto(Int_t nevent, Int_t sm) /*FOLD00*/ |
170c35f1 |
383 | { |
384 | // |
385 | // Test event loop |
386 | // fill one oroc and one iroc with random gaus |
387 | // |
388 | |
170c35f1 |
389 | gRandom->SetSeed(0); |
390 | |
289cc637 |
391 | for (Int_t ism=sm; ism<sm+1; ism++){ |
170c35f1 |
392 | for (Int_t ich=0; ich < 5; ich++){ |
393 | for (Int_t ipl=0; ipl < 6; ipl++){ |
f162af62 |
394 | for(Int_t irow = 0; irow < fGeo->GetRowMax(ipl,ich,ism); irow++){ |
395 | for(Int_t icol = 0; icol < fGeo->GetColMax(ipl); icol++){ |
170c35f1 |
396 | for (Int_t iTimeBin=0; iTimeBin<(30*nevent); iTimeBin++){ |
289cc637 |
397 | Int_t signal=(Int_t)(gRandom->Gaus(10.0,1.2)); |
f162af62 |
398 | if ( signal>0 )UpdateHisto((ipl+ich*6+ism*6*5),irow,icol,signal,fGeo->GetRowMax(ipl,ich,ism)); |
170c35f1 |
399 | } |
400 | } |
401 | } |
402 | } |
403 | } |
404 | } |
405 | return kTRUE; |
406 | } |
3a0f6479 |
407 | |
170c35f1 |
408 | //_____________________________________________________________________ |
409 | TH2F* AliTRDCalibPadStatus::GetHisto(Int_t det, TObjArray *arr, /*FOLD00*/ |
410 | Int_t nbinsY, Float_t ymin, Float_t ymax, |
411 | Char_t *type, Bool_t force) |
412 | { |
413 | // |
414 | // return pointer to histogram |
415 | // if force is true create a new histogram if it doesn't exist allready |
416 | // |
417 | if ( !force || arr->UncheckedAt(det) ) |
418 | return (TH2F*)arr->UncheckedAt(det); |
419 | |
420 | // if we are forced and histogram doesn't yes exist create it |
421 | Char_t name[255], title[255]; |
422 | |
423 | sprintf(name,"hCalib%s%.2d",type,det); |
424 | sprintf(title,"%s calibration histogram detector %.2d;ADC channel;Channel (pad)",type,det); |
425 | |
3a0f6479 |
426 | |
427 | Int_t nbchannels = fGeo->GetRowMax(GetPlane(det),GetChamber(det),GetSector(det))*fGeo->GetColMax(GetPlane(det)); |
170c35f1 |
428 | |
429 | // new histogram with calib information. One value for each pad! |
430 | TH2F* hist = new TH2F(name,title, |
431 | nbinsY, ymin, ymax, |
432 | nbchannels,0,nbchannels |
433 | ); |
434 | hist->SetDirectory(0); |
435 | arr->AddAt(hist,det); |
436 | return hist; |
437 | } |
3a0f6479 |
438 | |
170c35f1 |
439 | //_____________________________________________________________________ |
440 | TH2F* AliTRDCalibPadStatus::GetHisto(Int_t det, Bool_t force) /*FOLD00*/ |
441 | { |
442 | // |
443 | // return pointer to histogram |
444 | // if force is true create a new histogram if it doesn't exist allready |
445 | // |
446 | TObjArray *arr = &fHistoArray; |
447 | return GetHisto(det, arr, fAdcMax-fAdcMin, fAdcMin, fAdcMax, "Pedestal", force); |
448 | } |
3a0f6479 |
449 | |
170c35f1 |
450 | //_____________________________________________________________________ |
cf46274d |
451 | AliTRDarrayF* AliTRDCalibPadStatus::GetCal(Int_t det, TObjArray* arr, Bool_t force) /*FOLD00*/ |
170c35f1 |
452 | { |
453 | // |
454 | // return pointer to ROC Calibration |
455 | // if force is true create a new AliTRDarrayF if it doesn't exist allready |
456 | // |
457 | if ( !force || arr->UncheckedAt(det) ) |
458 | return (AliTRDarrayF*)arr->UncheckedAt(det); |
459 | |
460 | // if we are forced and histogram doesn't yes exist create it |
461 | AliTRDarrayF *croc = new AliTRDarrayF(); |
3a0f6479 |
462 | |
463 | Int_t nbpad = fGeo->GetRowMax(GetPlane(det),GetChamber(det),GetSector(det))*fGeo->GetColMax(GetPlane(det)); |
170c35f1 |
464 | |
465 | // new AliTRDCalROC. One value for each pad! |
466 | croc->Expand(nbpad); |
467 | for(Int_t k = 0; k < nbpad; k++){ |
468 | croc->AddAt(0.0,k); |
469 | } |
470 | arr->AddAt(croc,det); |
471 | return croc; |
472 | } |
3a0f6479 |
473 | |
170c35f1 |
474 | //_____________________________________________________________________ |
cf46274d |
475 | AliTRDCalROC* AliTRDCalibPadStatus::GetCalRoc(Int_t det, TObjArray* arr, Bool_t force) /*FOLD00*/ |
170c35f1 |
476 | { |
477 | // |
478 | // return pointer to ROC Calibration |
479 | // if force is true create a new AliTRDCalROC if it doesn't exist allready |
480 | // |
481 | if ( !force || arr->UncheckedAt(det) ) |
482 | return (AliTRDCalROC*)arr->UncheckedAt(det); |
483 | |
484 | // if we are forced and histogram doesn't yes exist create it |
485 | |
486 | // new AliTRDCalROC. One value for each pad! |
487 | AliTRDCalROC *croc = new AliTRDCalROC(GetPlane(det),GetChamber(det)); |
488 | arr->AddAt(croc,det); |
489 | return croc; |
490 | } |
3a0f6479 |
491 | |
170c35f1 |
492 | //_____________________________________________________________________ |
cf46274d |
493 | AliTRDarrayF* AliTRDCalibPadStatus::GetCalEntries(Int_t det, Bool_t force) /*FOLD00*/ |
170c35f1 |
494 | { |
495 | // |
496 | // return pointer to Carge ROC Calibration |
497 | // if force is true create a new histogram if it doesn't exist allready |
498 | // |
499 | TObjArray *arr = &fCalArrayEntries; |
cf46274d |
500 | return GetCal(det, arr, force); |
170c35f1 |
501 | } |
3a0f6479 |
502 | |
170c35f1 |
503 | //_____________________________________________________________________ |
cf46274d |
504 | AliTRDarrayF* AliTRDCalibPadStatus::GetCalMean(Int_t det, Bool_t force) /*FOLD00*/ |
170c35f1 |
505 | { |
506 | // |
507 | // return pointer to Carge ROC Calibration |
508 | // if force is true create a new histogram if it doesn't exist allready |
509 | // |
510 | TObjArray *arr = &fCalArrayMean; |
cf46274d |
511 | return GetCal(det, arr, force); |
170c35f1 |
512 | } |
3a0f6479 |
513 | |
170c35f1 |
514 | //_____________________________________________________________________ |
cf46274d |
515 | AliTRDarrayF* AliTRDCalibPadStatus::GetCalSquares(Int_t det, Bool_t force) /*FOLD00*/ |
170c35f1 |
516 | { |
517 | // |
518 | // return pointer to Carge ROC Calibration |
519 | // if force is true create a new histogram if it doesn't exist allready |
520 | // |
521 | TObjArray *arr = &fCalArraySquares; |
cf46274d |
522 | return GetCal(det, arr, force); |
170c35f1 |
523 | } |
3a0f6479 |
524 | |
170c35f1 |
525 | //_____________________________________________________________________ |
cf46274d |
526 | AliTRDCalROC* AliTRDCalibPadStatus::GetCalRocMean(Int_t det, Bool_t force) /*FOLD00*/ |
170c35f1 |
527 | { |
528 | // |
529 | // return pointer to Carge ROC Calibration |
530 | // if force is true create a new histogram if it doesn't exist allready |
531 | // |
532 | TObjArray *arr = &fCalRocArrayMean; |
cf46274d |
533 | return GetCalRoc(det, arr, force); |
170c35f1 |
534 | } |
3a0f6479 |
535 | |
170c35f1 |
536 | //_____________________________________________________________________ |
cf46274d |
537 | AliTRDCalROC* AliTRDCalibPadStatus::GetCalRocRMS(Int_t det, Bool_t force) /*FOLD00*/ |
170c35f1 |
538 | { |
539 | // |
540 | // return pointer to Carge ROC Calibration |
541 | // if force is true create a new histogram if it doesn't exist allready |
542 | // |
543 | TObjArray *arr = &fCalRocArrayRMS; |
cf46274d |
544 | return GetCalRoc(det, arr, force); |
170c35f1 |
545 | } |
3a0f6479 |
546 | |
170c35f1 |
547 | //_________________________________________________________________________ |
548 | void AliTRDCalibPadStatus::Analyse() /*FOLD00*/ |
549 | { |
550 | // |
551 | // Calcul the rms properly |
552 | // |
553 | |
554 | for(Int_t idet = 0; idet < 540; idet++){ |
555 | |
556 | // Take the stuff |
557 | fCalEntries = ((AliTRDarrayF *)GetCalEntries(idet)); |
558 | fCalMean = ((AliTRDarrayF *)GetCalMean(idet)); |
559 | fCalSquares = ((AliTRDarrayF *)GetCalSquares(idet)); |
560 | |
561 | if(!fCalEntries) continue; |
562 | |
563 | AliTRDCalROC *calRocMean = ((AliTRDCalROC *)GetCalRocMean(idet,kTRUE)); |
564 | AliTRDCalROC *calRocRMS = ((AliTRDCalROC *)GetCalRocRMS(idet,kTRUE)); |
565 | |
566 | // range channels |
567 | Int_t channels = calRocMean->GetNchannels(); |
568 | |
569 | for(Int_t ichannels = 0 ; ichannels < channels; ichannels++){ |
570 | |
571 | Float_t entries = fCalEntries->At(ichannels); |
572 | Float_t mean = fCalMean->At(ichannels); |
573 | Float_t squares = fCalSquares->At(ichannels); |
574 | |
575 | Float_t rms = 0.0; |
576 | if(entries > 0){ |
577 | Double_t rm = TMath::Abs(squares-(mean*mean)); |
578 | rms = TMath::Sqrt(rm); |
579 | calRocRMS->SetValue(ichannels,rms/10.0); |
580 | calRocMean->SetValue(ichannels,mean/10.0); |
581 | } |
582 | } |
583 | } |
584 | } |
3a0f6479 |
585 | |
170c35f1 |
586 | //_____________________________________________________________________ |
587 | void AliTRDCalibPadStatus::AnalyseHisto() /*FOLD00*/ |
588 | { |
589 | // |
590 | // Calculate calibration constants |
591 | // |
592 | |
593 | Int_t nbinsAdc = fAdcMax-fAdcMin; |
594 | |
595 | TVectorD param(3); |
596 | TMatrixD dummy(3,3); |
597 | |
598 | Float_t *array_hP=0; |
599 | |
600 | |
601 | for (Int_t idet=0; idet<540; idet++){ |
602 | TH2F *hP = GetHisto(idet); |
603 | if ( !hP ) { |
604 | continue; |
605 | } |
606 | |
607 | AliTRDCalROC *rocMean = GetCalRocMean(idet,kTRUE); |
608 | AliTRDCalROC *rocRMS = GetCalRocRMS(idet,kTRUE); |
609 | |
610 | array_hP = hP->GetArray(); |
611 | Int_t nChannels = rocMean->GetNchannels(); |
612 | |
613 | for (Int_t iChannel=0; iChannel<nChannels; iChannel++){ |
614 | Int_t offset = (nbinsAdc+2)*(iChannel+1)+1; |
615 | Double_t ret = AliMathBase::FitGaus(array_hP+offset,nbinsAdc,fAdcMin,fAdcMax,¶m,&dummy); |
616 | // if the fitting failed set noise and pedestal to 0 |
6ace5fe2 |
617 | if ((ret==-4) || (ret==-1) || (ret==-2)) { |
170c35f1 |
618 | param[1]=0.0; |
619 | param[2]=0.0; |
620 | } |
621 | if((param[1]/10.0) > 65534.0) param[1] = 0.0; |
622 | if((param[2]/10.0) > 65534.0) param[2] = 0.0; |
623 | rocMean->SetValue(iChannel,param[1]/10.0); |
624 | rocRMS->SetValue(iChannel,param[2]/10.0); |
625 | } |
626 | } |
627 | |
628 | } |
3a0f6479 |
629 | |
170c35f1 |
630 | //_______________________________________________________________________________________ |
631 | AliTRDCalPadStatus* AliTRDCalibPadStatus::CreateCalPadStatus() |
632 | { |
633 | // |
6ace5fe2 |
634 | // Create Pad Status out of Mean and RMS values |
170c35f1 |
635 | // |
636 | |
637 | AliTRDCalPadStatus* obj = new AliTRDCalPadStatus("padstatus", "padstatus"); |
638 | |
639 | for (Int_t idet=0; idet<540; ++idet) |
640 | { |
641 | AliTRDCalSingleChamberStatus *calROC = obj->GetCalROC(idet); |
642 | |
643 | //Take the stuff |
170c35f1 |
644 | AliTRDCalROC *calRocMean = ((AliTRDCalROC *)GetCalRocMean(idet)); |
645 | AliTRDCalROC *calRocRMS = ((AliTRDCalROC *)GetCalRocRMS(idet)); |
646 | |
647 | if ( !calRocMean ) { |
648 | for(Int_t k = 0; k < calROC->GetNchannels(); k++){ |
649 | calROC->SetStatus(k,AliTRDCalPadStatus::kMasked); |
650 | } |
170c35f1 |
651 | continue; |
652 | } |
6ace5fe2 |
653 | |
170c35f1 |
654 | //Range |
655 | Int_t channels = calROC->GetNchannels(); |
6ace5fe2 |
656 | |
657 | Double_t rmsmean = calRocMean->GetRMS()*10.0; |
658 | Double_t meanmean = calRocMean->GetMean()*10.0; |
659 | Double_t meansquares = calRocRMS->GetMean()*10.0; |
170c35f1 |
660 | |
661 | |
662 | for(Int_t ich = 0; ich < channels; ich++){ |
663 | |
6ace5fe2 |
664 | Float_t mean = calRocMean->GetValue(ich)*10.0; |
170c35f1 |
665 | Float_t rms = calRocRMS->GetValue(ich)*10.0; |
6ace5fe2 |
666 | |
667 | if((rms <= 0.0001) || (TMath::Abs(mean-meanmean)>(5*rmsmean)) || (TMath::Abs(rms)>(5.0*TMath::Abs(meansquares)))) calROC->SetStatus(ich, AliTRDCalPadStatus::kMasked); |
668 | |
669 | } |
170c35f1 |
670 | } |
671 | |
672 | return obj; |
673 | |
674 | } |
3a0f6479 |
675 | |
289cc637 |
676 | //_______________________________________________________________________________________ |
677 | AliTRDCalPad* AliTRDCalibPadStatus::CreateCalPad() |
678 | { |
679 | // |
680 | // Create Pad Noise out of RMS values |
681 | // |
682 | |
683 | AliTRDCalPad* obj = new AliTRDCalPad("PadNoise", "PadNoise"); |
684 | |
685 | |
686 | for (Int_t det=0; det<AliTRDgeometry::kNdet; ++det) { |
687 | |
688 | AliTRDCalROC *calROC22 = obj->GetCalROC(det); |
689 | |
690 | AliTRDCalROC *calRocRMS = ((AliTRDCalROC *)GetCalRocRMS(det,kTRUE)); |
691 | |
692 | for(Int_t k = 0; k < calROC22->GetNchannels(); k++){ |
693 | calROC22->SetValue(k,calRocRMS->GetValue(k)); |
694 | } |
695 | |
696 | } |
697 | |
698 | return obj; |
699 | |
700 | } |
701 | |
702 | //_______________________________________________________________________________________ |
703 | AliTRDCalDet* AliTRDCalibPadStatus::CreateCalDet() |
704 | { |
705 | // |
706 | // Create Det Noise correction factor |
707 | // |
708 | |
709 | AliTRDCalDet* obj = new AliTRDCalDet("DetNoise", "DetNoise (correction factor)"); |
710 | |
711 | for(Int_t l = 0; l < 540; l++){ |
712 | obj->SetValue(l,10.0); |
713 | } |
714 | |
715 | return obj; |
716 | |
717 | } |
718 | |
170c35f1 |
719 | //_____________________________________________________________________ |
720 | void AliTRDCalibPadStatus::DumpToFile(const Char_t *filename, const Char_t *dir, Bool_t append) /*FOLD00*/ |
721 | { |
722 | // |
723 | // Write class to file |
724 | // |
725 | |
726 | TString sDir(dir); |
727 | TString option; |
728 | |
729 | if ( append ) |
730 | option = "update"; |
731 | else |
732 | option = "recreate"; |
733 | |
734 | TDirectory *backup = gDirectory; |
735 | TFile f(filename,option.Data()); |
736 | f.cd(); |
737 | if ( !sDir.IsNull() ){ |
738 | f.mkdir(sDir.Data()); |
739 | f.cd(sDir); |
740 | } |
741 | this->Write(); |
742 | f.Close(); |
743 | |
744 | if ( backup ) backup->cd(); |
3a0f6479 |
745 | } |
746 | |
6ace5fe2 |
747 | //_____________________________________________________________________ |
748 | void AliTRDCalibPadStatus::SetCalRocMean(AliTRDCalROC *mean, Int_t det) /*FOLD00*/ |
749 | { |
750 | // |
751 | // Put the AliTRDCalROC in the array fCalRocArrayMean |
752 | // |
753 | |
754 | |
755 | AliTRDCalROC *rocMean = GetCalRocMean(det,kTRUE); |
756 | |
757 | Int_t nChannels = rocMean->GetNchannels(); |
758 | |
759 | for (Int_t iChannel=0; iChannel<nChannels; iChannel++){ |
760 | |
761 | rocMean->SetValue(iChannel,mean->GetValue(iChannel)); |
762 | |
763 | } |
764 | |
765 | } |
766 | |
767 | //_____________________________________________________________________ |
768 | void AliTRDCalibPadStatus::SetCalRocRMS(AliTRDCalROC *rms, Int_t det) /*FOLD00*/ |
769 | { |
770 | // |
771 | // Put the AliTRDCalROC in the array fCalRocArrayRMS |
772 | // |
773 | |
774 | |
775 | AliTRDCalROC *rocRms = GetCalRocRMS(det,kTRUE); |
776 | |
777 | Int_t nChannels = rocRms->GetNchannels(); |
778 | |
779 | for (Int_t iChannel=0; iChannel<nChannels; iChannel++){ |
780 | |
781 | rocRms->SetValue(iChannel,rms->GetValue(iChannel)); |
782 | |
783 | } |
784 | |
785 | } |
786 | |
3a0f6479 |
787 | //_____________________________________________________________________________ |
170c35f1 |
788 | Int_t AliTRDCalibPadStatus::GetPlane(Int_t d) const |
789 | { |
790 | // |
791 | // Reconstruct the plane number from the detector number |
792 | // |
793 | |
794 | return ((Int_t) (d % 6)); |
795 | |
796 | } |
797 | |
798 | //_____________________________________________________________________________ |
799 | Int_t AliTRDCalibPadStatus::GetChamber(Int_t d) const |
800 | { |
801 | // |
802 | // Reconstruct the chamber number from the detector number |
803 | // |
804 | |
805 | return ((Int_t) (d % 30) / 6); |
806 | |
807 | } |
3a0f6479 |
808 | |
170c35f1 |
809 | //_____________________________________________________________________________ |
810 | Int_t AliTRDCalibPadStatus::GetSector(Int_t d) const |
811 | { |
812 | // |
813 | // Reconstruct the sector number from the detector number |
814 | // |
815 | |
816 | return ((Int_t) (d / 30)); |
817 | |
818 | } |
819 | |
820 | |