git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Online LookUpTable the same as offline
[u/mrichter/AliRoot.git] / TRD / AliTRDCalibPadStatus.cxx
CommitLineData
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/////////////////////////
47ped.AnalyseHisto();
48//Take the histo
49TH1F * histo = ped.GetHisto(31);
50histo->SetEntries(1);
51histo->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 89ClassImp(AliTRDCalibPadStatus) /*FOLD00*/
90
91//_____________________________________________________________________
92AliTRDCalibPadStatus::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//_____________________________________________________________________
118AliTRDCalibPadStatus::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//_____________________________________________________________________
166AliTRDCalibPadStatus& 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//_____________________________________________________________________
178AliTRDCalibPadStatus::~AliTRDCalibPadStatus() /*FOLD00*/
179{
180 //
181 // destructor
182 //
f162af62 183 if (fGeo) {
184 delete fGeo;
185 }
170c35f1 186}
f162af62 187
170c35f1 188//_____________________________________________________________________
189Int_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//_____________________________________________________________________
226Int_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 250Int_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 313Int_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 328Int_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 355Bool_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 382Bool_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//_____________________________________________________________________
409TH2F* 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//_____________________________________________________________________
440TH2F* 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 451AliTRDarrayF* 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 475AliTRDCalROC* 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 493AliTRDarrayF* 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 504AliTRDarrayF* 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 515AliTRDarrayF* 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 526AliTRDCalROC* 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 537AliTRDCalROC* 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//_________________________________________________________________________
548void 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//_____________________________________________________________________
587void 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,&param,&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//_______________________________________________________________________________________
631AliTRDCalPadStatus* 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//_______________________________________________________________________________________
677AliTRDCalPad* 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//_______________________________________________________________________________________
703AliTRDCalDet* 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//_____________________________________________________________________
720void 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//_____________________________________________________________________
748void 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//_____________________________________________________________________
768void 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 788Int_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//_____________________________________________________________________________
799Int_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//_____________________________________________________________________________
810Int_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