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