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