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