Removing useless flag.
[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 // Authors:
59 //   R. Bailhache (R.Bailhache@gsi.de, rbailhache@ikf.uni-frankfurt.de)
60 //   J. Book (jbook@ikf.uni-frankfurt.de)
61 //                                                                                                    //
62 ////////////////////////////////////////////////////////////////////////////
63
64
65 //Root includes
66 #include <TObjArray.h>
67 #include <TH2F.h>
68 #include <TString.h>
69 #include <TMath.h>
70 #include <TRandom.h>
71
72 //#include <TRandom.h>
73 #include <TDirectory.h>
74 #include <TFile.h>
75
76 //AliRoot includes
77 #include <AliMathBase.h>
78 #include "AliRawReader.h"
79 #include "AliRawReaderRoot.h"
80 #include "AliRawReaderDate.h"
81
82 //header file
83 #include "AliLog.h"
84 #include "AliTRDCalibPadStatus.h"
85 #include "AliTRDgeometry.h"
86 #include "AliTRDCommonParam.h"
87 #include "./Cal/AliTRDCalROC.h"
88 #include "./Cal/AliTRDCalPadStatus.h"
89 #include "./Cal/AliTRDCalDet.h"
90 #include "./Cal/AliTRDCalPad.h"
91 #include "./Cal/AliTRDCalSingleChamberStatus.h"
92
93 #include "AliTRDdigitsManager.h"
94 #include "AliTRDdigitsParam.h"
95 #include "AliTRDSignalIndex.h"
96 #include "AliTRDarraySignal.h"
97 #include "AliTRDarrayADC.h"
98 #include "AliTRDfeeParam.h"
99
100 #include "AliTRDrawStream.h"
101
102 #ifdef ALI_DATE
103 #include "event.h"
104 #endif
105
106 ClassImp(AliTRDCalibPadStatus) /*FOLD00*/
107
108 //_____________________________________________________________________
109 AliTRDCalibPadStatus::AliTRDCalibPadStatus() : /*FOLD00*/
110   TObject(),
111   fGeo(0),
112   fAdcMin(0),
113   fAdcMax(21),
114   fDetector(-1),
115   fNumberOfTimeBins(0),
116   fCalRocArrayMean(540),
117   fCalRocArrayRMS(540),
118   fCalRocArrayMeand(540),
119   fCalRocArrayRMSd(540),
120   fHistoArray(540)
121 {
122     //
123     // default constructor
124     //
125
126   fGeo = new AliTRDgeometry();
127
128 }
129
130 //_____________________________________________________________________
131 AliTRDCalibPadStatus::AliTRDCalibPadStatus(const AliTRDCalibPadStatus &ped) : /*FOLD00*/
132   TObject(ped),
133   fGeo(0),
134   fAdcMin(ped.GetAdcMin()),
135   fAdcMax(ped.GetAdcMax()),
136   fDetector(ped.fDetector),
137   fNumberOfTimeBins(ped.fNumberOfTimeBins),
138   fCalRocArrayMean(540),
139   fCalRocArrayRMS(540),
140   fCalRocArrayMeand(540),
141   fCalRocArrayRMSd(540),
142   fHistoArray(540)
143 {
144     //
145     // copy constructor
146     //
147     for (Int_t idet = 0; idet < 540; idet++){
148         const AliTRDCalROC *calRocMean  = (AliTRDCalROC*)ped.fCalRocArrayMean.UncheckedAt(idet);
149         const AliTRDCalROC *calRocRMS   = (AliTRDCalROC*)ped.fCalRocArrayRMS.UncheckedAt(idet);
150         const AliTRDCalROC *calRocMeand = (AliTRDCalROC*)ped.fCalRocArrayMeand.UncheckedAt(idet);
151         const AliTRDCalROC *calRocRMSd  = (AliTRDCalROC*)ped.fCalRocArrayRMSd.UncheckedAt(idet);
152         const TH2F         *hped        = (TH2F*)ped.fHistoArray.UncheckedAt(idet);
153     
154         if ( calRocMean != 0x0 ) fCalRocArrayMean.AddAt(new AliTRDCalROC(*calRocMean), idet);
155         if ( calRocRMS != 0x0 )  fCalRocArrayRMS.AddAt(new AliTRDCalROC(*calRocRMS), idet);
156
157         if ( calRocMeand != 0x0 ) fCalRocArrayMeand.AddAt(new AliTRDCalROC(*calRocMeand), idet);
158         if ( calRocRMSd != 0x0 )  fCalRocArrayRMSd.AddAt(new AliTRDCalROC(*calRocRMSd), idet);
159
160         if ( hped != 0x0 ){
161           TH2F *hNew = new TH2F(*hped);
162           hNew->SetDirectory(0);
163           fHistoArray.AddAt(hNew,idet);
164         }
165         
166     }
167     if (fGeo) {
168       delete fGeo;
169     }
170     fGeo = new AliTRDgeometry();
171 }
172
173 //_____________________________________________________________________
174 AliTRDCalibPadStatus& AliTRDCalibPadStatus::operator = (const  AliTRDCalibPadStatus &source)
175 {
176   //
177   // assignment operator
178   //
179   if (&source == this) return *this;
180   new (this) AliTRDCalibPadStatus(source);
181
182   return *this;
183 }
184 //_____________________________________________________________________
185 AliTRDCalibPadStatus::~AliTRDCalibPadStatus() /*FOLD00*/
186 {
187   //
188   // destructor
189   //
190   fCalRocArrayMean.Delete();
191   fCalRocArrayRMS.Delete();
192   fCalRocArrayMeand.Delete();
193   fCalRocArrayRMSd.Delete();
194   fHistoArray.Delete();
195   if (fGeo) {
196     delete fGeo;
197   }
198 }
199 //_____________________________________________________________________
200 void AliTRDCalibPadStatus::Destroy()
201 {
202   //
203   // Destroy
204   //
205   fCalRocArrayMean.Delete();
206   fCalRocArrayRMS.Delete();
207   fCalRocArrayMeand.Delete();
208   fCalRocArrayRMSd.Delete();
209   fHistoArray.Delete();
210 }
211 //_____________________________________________________________________
212 Int_t AliTRDCalibPadStatus::UpdateHisto(const Int_t icdet, /*FOLD00*/
213                                          const Int_t icRow,
214                                          const Int_t icCol,
215                                          const Int_t csignal,
216                                          const Int_t crowMax,
217                                          const Int_t ccold,
218                                          const Int_t icMcm,
219                                          const Int_t icRob
220                                          )
221 {
222   //
223   // Signal filling methode 
224   //
225   Int_t nbchannel = icRow+icCol*crowMax;
226   Int_t mCm = icMcm%4;
227   Int_t rOb = icRob%2;
228
229   // now the case of double read channel
230   if(ccold > 0){
231     nbchannel = (((ccold-1)*8+ (mCm+rOb*4))*crowMax+icRow)+144*crowMax;
232     //printf("nbchannel %d, ccold %d, icMcm %d, crowMax %d, icRow %d\n",nbchannel,ccold,icMcm,crowMax,icRow);
233   }
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   
239   Int_t bin = 0;
240   
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)->Fill(csignal,nbchannel);
245
246   GetHisto(icdet,kTRUE)->GetArray()[bin]++;
247   
248   return 0;
249 }
250 //_____________________________________________________________________
251 Int_t AliTRDCalibPadStatus::ProcessEvent(AliRawReader *rawReader)
252 {
253   //
254   // RawReader = AliTRDrawStream (Jochen Klein) 
255   //
256   // Event Processing loop - AliTRDRawStreamCosmic
257   // 0 time bin problem or zero suppression
258   // 1 no input
259   // 2 input
260   // Raw version number: 
261   // [3,31] non zero suppressed
262   // 2,4 and [32,63] zero suppressed 
263   //
264   
265  
266
267   Int_t withInput = 1;
268
269   AliTRDdigitsManager *digitsManager = new AliTRDdigitsManager(kTRUE);
270   digitsManager->CreateArrays();
271
272   AliTRDrawStream *rawStream = new AliTRDrawStream(rawReader);
273   rawStream->SetDigitsManager(digitsManager);
274   //rawStream->SetNoErrorWarning();
275   //rawStream->SetSharedPadReadout(kTRUE);
276   
277   AliTRDfeeParam *feeParam = AliTRDfeeParam::Instance();
278
279   Int_t det    = 0;
280   while ((det = rawStream->NextChamber(digitsManager, NULL, NULL)) >= 0) { //idetector
281     if (digitsManager->GetIndexes(det)->HasEntry()) {//QA
282       //      printf("there is ADC data on this chamber!\n");
283       
284        AliTRDarrayADC *digits = (AliTRDarrayADC *) digitsManager->GetDigits(det); //mod
285       if (digits->HasData()) { //array
286         
287         AliTRDSignalIndex   *indexes = digitsManager->GetIndexes(det);
288         if (indexes->IsAllocated() == kFALSE) {
289           AliError("Indexes do not exist!");
290           break;
291         }
292         Int_t iRow  = 0;
293         Int_t iCol  = 0;
294         indexes->ResetCounters();
295         
296         while (indexes->NextRCIndex(iRow, iCol)) { //column,row
297         
298           AliTRDdigitsParam *digitParam = (AliTRDdigitsParam *)digitsManager->GetDigitsParam();
299           
300           Int_t mcm          = 0;     // MCM from AliTRDfeeParam
301           Int_t rob          = 0;     // ROB from AliTRDfeeParam
302           Int_t extCol       = 0;     // extended column from AliTRDfeeParam  
303           mcm = feeParam->GetMCMfromPad(iRow,iCol);
304           rob = feeParam->GetROBfromPad(iRow,iCol);
305           
306           Int_t idetector  = det;                            //  current detector
307           Int_t iRowMax    = 16;                              //  current rowmax
308           if(GetStack(det) == 2) iRowMax = 12;
309                   
310           Int_t adc        = 20 - (iCol%18) -1;                 //  current adc
311           Int_t col        = 0;                              //  col!=0 ->Shared Pad
312           extCol = feeParam->GetExtendedPadColFromADC(rob,mcm,adc);
313           //printf("  iCol %d  iRow %d  iRowMax %d  rob %d  mcm %d  adc %d  extCol %d\n",iCol,iRow,iRowMax,rob,mcm,adc,extCol);   
314           
315           // Signal for regular pads
316           Int_t nbtimebin  = digitParam->GetNTimeBins(idetector);  //  number of time bins read from data         
317           for(Int_t k = 0; k < nbtimebin; k++){
318             Short_t signal = 0;
319             signal = digits->GetData(iRow,iCol,k);
320
321             if(signal>0) {
322               UpdateHisto(idetector,iRow,iCol,signal,iRowMax,col,mcm,rob);
323             }
324           }
325           
326           
327           
328           if((adc==3-1 || adc==20-1 || adc==19-1) && (iCol > 1 && iCol <142)  ) { //SHARED PADS
329             
330             switch(adc) {
331             case 2:  
332               adc = 20;                                       //shared Pad adc 
333               mcm = feeParam->GetMCMfromSharedPad(iRow,iCol); //shared Pad mcm 
334               col =  1;
335               break;
336             case 19:  
337               adc = 1;                                        //shared Pad adc  
338               mcm = feeParam->GetMCMfromSharedPad(iRow,iCol); //shared Pad mcm  
339               col =  2;
340               break;
341             case 18: 
342               adc =  0;                                       //shared Pad adc  
343               mcm = feeParam->GetMCMfromSharedPad(iRow,iCol); //shared Pad mcm 
344               col =  3;
345               break;
346             }
347             rob = feeParam->GetROBfromSharedPad(iRow,iCol);     //shared Pad rob 
348             
349             
350             extCol = feeParam->GetExtendedPadColFromADC(rob,mcm,adc);     //extended pad col via the shared pad rob,mcm and adc
351             
352             //printf("SHARED PAD ---  iCol %d  iRow %d  rob %d  mcm %d  adc %d  extCol %d  col %d\n",iCol,iRow,rob,mcm,adc,extCol,col);
353             for(Int_t k = 0; k < nbtimebin; k++){
354               Short_t signal = 0;
355               signal = digits->GetDataByAdcCol(iRow,extCol,k);
356               
357               if(signal>0) {
358                 UpdateHisto(idetector,iRow,iCol,signal,iRowMax,col,mcm,rob);
359               }
360             }
361           } //shared pads end
362           
363           
364           withInput = 2;
365         }//column,row
366
367       }//array
368     }//QA
369     digitsManager->ClearArrays(det);
370   }//idetector
371   delete digitsManager;
372   delete rawStream;
373   return withInput;
374   
375 }
376
377 //_____________________________________________________________________
378 TH2F* AliTRDCalibPadStatus::GetHisto(Int_t det, TObjArray *arr, /*FOLD00*/
379                                   Int_t nbinsY, Float_t ymin, Float_t ymax,
380                                   const Char_t *type, Bool_t force)
381 {
382     //
383     // return pointer to histogram
384     // if force is true create a new histogram if it doesn't exist allready
385     //
386     if ( !force || arr->UncheckedAt(det) )
387         return (TH2F*)arr->UncheckedAt(det);
388
389     // if we are forced and histogram doesn't yes exist create it
390     Char_t name[255], title[255];
391
392     snprintf(name,255,"hCalib%s%.3d",type,det);
393     snprintf(title,255,"%s calibration histogram detector %.2d;ADC channel;Channel (pad)",type,det);
394
395    
396     Int_t nbchannels = fGeo->GetRowMax(GetLayer(det),GetStack(det),GetSector(det))*fGeo->GetColMax(GetLayer(det));
397     
398     // we will add 3*8*rowMax channels at the end for the double counted
399     nbchannels += 3*8*(fGeo->GetRowMax(GetLayer(det),GetStack(det),GetSector(det)));
400
401
402     // new histogram with calib information. One value for each pad!
403     TH2F* hist = new TH2F(name,title,
404                           nbinsY, ymin, ymax,
405                           nbchannels,0,nbchannels
406                           );
407     hist->SetDirectory(0);
408     arr->AddAt(hist,det);
409     return hist;
410 }
411
412 //_____________________________________________________________________
413 TH2F* AliTRDCalibPadStatus::GetHisto(Int_t det, Bool_t force) /*FOLD00*/
414 {
415     //
416     // return pointer to histogram
417     // if force is true create a new histogram if it doesn't exist allready
418     //
419     TObjArray *arr = &fHistoArray;
420     return GetHisto(det, arr, fAdcMax-fAdcMin, fAdcMin-0.5, fAdcMax-0.5, "Pedestal", force);
421 }
422
423 //_____________________________________________________________________
424 AliTRDCalROC* AliTRDCalibPadStatus::GetCalRoc(Int_t det, TObjArray* arr, Bool_t force) /*FOLD00*/
425 {
426     //
427     // return pointer to ROC Calibration
428     // if force is true create a new AliTRDCalROC if it doesn't exist allready
429     //
430     if ( !force || arr->UncheckedAt(det) )
431         return (AliTRDCalROC*)arr->UncheckedAt(det);
432
433     // if we are forced and histogram doesn't yes exist create it
434
435     // new AliTRDCalROC. One value for each pad!
436     AliTRDCalROC *croc = new AliTRDCalROC(GetLayer(det),GetStack(det));
437     arr->AddAt(croc,det);
438     return croc;
439 }
440 //_____________________________________________________________________
441 AliTRDCalROC* AliTRDCalibPadStatus::GetCalRocMean(Int_t det, Bool_t force) /*FOLD00*/
442 {
443     //
444     // return pointer to Carge ROC Calibration
445     // if force is true create a new histogram if it doesn't exist allready
446     //
447     TObjArray *arr = &fCalRocArrayMean;
448     return GetCalRoc(det, arr, force);
449 }
450
451 //_____________________________________________________________________
452 AliTRDCalROC* AliTRDCalibPadStatus::GetCalRocRMS(Int_t det, Bool_t force) /*FOLD00*/
453 {
454     //
455     // return pointer to Carge ROC Calibration
456     // if force is true create a new histogram if it doesn't exist allready
457     //
458     TObjArray *arr = &fCalRocArrayRMS;
459     return GetCalRoc(det, arr, force);
460 }
461 //_____________________________________________________________________
462 AliTRDCalROC* AliTRDCalibPadStatus::GetCalRocMeand(Int_t det, Bool_t force) /*FOLD00*/
463 {
464     //
465     // return pointer to Carge ROC Calibration
466     // if force is true create a new histogram if it doesn't exist allready
467     //
468     TObjArray *arr = &fCalRocArrayMeand;
469     return GetCalRoc(det, arr, force);
470 }
471
472 //_____________________________________________________________________
473 AliTRDCalROC* AliTRDCalibPadStatus::GetCalRocRMSd(Int_t det, Bool_t force) /*FOLD00*/
474 {
475     //
476     // return pointer to Carge ROC Calibration
477     // if force is true create a new histogram if it doesn't exist allready
478     //
479     TObjArray *arr = &fCalRocArrayRMSd;
480     return GetCalRoc(det, arr, force);
481 }
482
483 //_____________________________________________________________________
484 void AliTRDCalibPadStatus::AnalyseHisto() /*FOLD00*/
485 {
486     //
487     //  Calculate calibration constants
488     //
489
490     Int_t nbinsAdc = fAdcMax-fAdcMin;
491
492     TVectorD param(4);
493     TMatrixD dummy(3,3);
494
495     Float_t *arrayHP=0;
496
497
498     for (Int_t idet=0; idet<540; idet++){
499         TH2F *hP = GetHisto(idet);
500         if ( !hP ) {
501           continue;
502         }
503
504         //printf("Entries for %d\n",idet);
505
506         AliTRDCalROC *rocMean     = GetCalRocMean(idet,kTRUE);
507         AliTRDCalROC *rocRMS      = GetCalRocRMS(idet,kTRUE);
508
509         arrayHP = hP->GetArray();
510         Int_t nChannels = rocMean->GetNchannels();
511
512         for (Int_t iChannel=0; iChannel<nChannels; iChannel++){
513             Int_t offset = (nbinsAdc+2)*(iChannel+1)+1;
514             Double_t ret = AliMathBase::FitGaus(arrayHP+offset,nbinsAdc,fAdcMin-0.5,fAdcMax-0.5,&param,&dummy);
515             // if the fitting failed set noise and pedestal to 0
516             if ((ret==-4) || (ret==-1) || (ret==-2)) {
517                 param[1]=0.0;
518                 param[2]=0.0;
519             }
520             if((param[1]/10.0) > 65534.0) param[1] = 0.0;
521             if((param[2]/10.0) > 65534.0) param[2] = 0.0;
522             rocMean->SetValue(iChannel,param[1]/10.0);
523             rocRMS->SetValue(iChannel,param[2]/10.0);
524         }
525
526         // here we analyse doubled read channels
527         
528         AliTRDCalROC *rocMeand     = GetCalRocMeand(idet,kTRUE);
529         AliTRDCalROC *rocRMSd      = GetCalRocRMSd(idet,kTRUE);
530
531         Int_t nrows = rocMeand->GetNrows();
532         Int_t shift = 144*nrows;
533         Int_t total = shift+3*8*nrows; 
534
535         for (Int_t iChannel=shift; iChannel<total; iChannel++){
536             Int_t offset = (nbinsAdc+2)*(iChannel+1)+1;
537             Double_t ret = AliMathBase::FitGaus(arrayHP+offset,nbinsAdc,fAdcMin-0.5,fAdcMax-0.5,&param,&dummy);
538             // if the fitting failed set noise and pedestal to 0
539             if ((ret==-4) || (ret==-1) || (ret==-2)) {
540                 param[1]=0.0;
541                 param[2]=0.0;
542             }
543             if((param[1]/10.0) > 65534.0) param[1] = 0.0;
544             if((param[2]/10.0) > 65534.0) param[2] = 0.0;
545             
546             // here we have to recalculate backward
547             Int_t nb   = iChannel-shift;
548             Int_t row  = nb%nrows;
549             Int_t j    = (Int_t)(nb/nrows);
550             Int_t imcm = j%8;
551             Int_t icol = (Int_t)(j/8);
552             
553             Int_t finalcol = 18*imcm;
554             if(icol > 0) icol += 17;
555             else icol = -1;
556             finalcol += icol;
557
558             Int_t channel = row+finalcol*nrows;
559
560             //printf("iChannel %d, nrows %d, finalcol %d, row %d, channel %d\n",iChannel,nrows,finalcol,row,channel);
561             if((finalcol < 0) || (finalcol >= 144)) continue;
562
563             rocMeand->SetValue(channel,param[1]/10.0);
564             rocRMSd->SetValue(channel,param[2]/10.0);
565         }
566
567     }
568       
569 }
570
571 //_______________________________________________________________________________________
572 AliTRDCalPadStatus* AliTRDCalibPadStatus::CreateCalPadStatus()
573 {
574   //
575   // Create Pad Status out of Mean and RMS values
576   // The chamber without data are masked, this is the corrected in the preprocessor
577   //
578
579   AliTRDCalPadStatus* obj = new AliTRDCalPadStatus("padstatus", "padstatus");
580   
581   for (Int_t idet=0; idet<540; ++idet)
582     {
583       AliTRDCalSingleChamberStatus *calROC = obj->GetCalROC(idet);
584
585
586       if ( !GetCalRocMean(idet)) {
587         for(Int_t k = 0; k < calROC->GetNchannels(); k++){
588           calROC->SetStatus(k,AliTRDCalPadStatus::kNotConnected);
589         }
590         continue;
591       }
592       
593
594       //Take the stuff
595       AliTRDCalROC *calRocMean    = new AliTRDCalROC(*( (AliTRDCalROC *) GetCalRocMean(idet)));
596       AliTRDCalROC *calRocRMS     = new AliTRDCalROC(*( (AliTRDCalROC *) GetCalRocRMS(idet)));
597
598       //Take the stuff second chance
599       AliTRDCalROC *calRocMeand    = new AliTRDCalROC(*( (AliTRDCalROC *) GetCalRocMeand(idet)));
600       AliTRDCalROC *calRocRMSd     = new AliTRDCalROC(*( (AliTRDCalROC *) GetCalRocRMSd(idet)));
601
602       calRocRMS->Unfold();
603       calRocRMSd->Unfold();
604
605      
606       //Range
607       Int_t row      = calROC->GetNrows();
608       Int_t col      = calROC->GetNcols();
609       
610       Double_t rmsmean       = calRocMean->GetRMS()*10.0;
611       Double_t meanmean      = calRocMean->GetMean()*10.0;
612       Double_t meansquares   = calRocRMS->GetMean();
613
614       
615       for(Int_t irow = 0; irow < row; irow++){
616         
617         // for bridged pads
618         Float_t meanprevious = 0.0;
619         Float_t rmsprevious  = 0.0; 
620         Float_t mean         = 0.0;
621         Float_t rms          = 0.0;
622         
623         for(Int_t icol = 0; icol < col; icol++){
624           
625           mean     = calRocMean->GetValue(icol,irow)*10.0;
626           rms      = calRocRMS->GetValue(icol,irow);
627
628           if(icol > 0) {
629             meanprevious     = calRocMean->GetValue((icol -1),irow)*10.0;
630             rmsprevious      = calRocRMS->GetValue((icol - 1),irow);
631           }
632           
633           Bool_t pb = kFALSE;
634           // masked if two noisy
635           if((rms <= 0.0001) || (TMath::Abs(mean-meanmean)>(5*rmsmean)) || (TMath::Abs(rms)>(5.0*TMath::Abs(meansquares)))) {
636             
637             pb = kTRUE;
638             // look at second chance
639             Float_t meand     = calRocMeand->GetValue(icol,irow)*10.0;
640             Float_t rmsd      = calRocRMSd->GetValue(icol,irow);
641             
642             if((rmsd <= 0.0001) || (TMath::Abs(meand-meanmean)>(5*rmsmean)) || (TMath::Abs(rmsd)>(5.0*TMath::Abs(meansquares)))) {
643               if((rmsd <= 0.0001) && (rms <= 0.0001)) {
644                 calROC->SetStatus(icol,irow,AliTRDCalPadStatus::kNotConnected);
645               }
646               else {
647                 calROC->SetStatus(icol, irow, AliTRDCalPadStatus::kMasked);
648               }
649             }
650             else {
651               calROC->SetStatus(icol, irow, AliTRDCalPadStatus::kReadSecond);
652             }
653           }
654
655
656           // bridge if previous pad found something
657           if(!pb) {
658             if((TMath::Abs(meanprevious-mean)<0.000001) && (TMath::Abs(rmsprevious-rms)<0.000001) && (mean > 0.0001)) {
659               //printf("mean previous %f, mean %f, rms %f, rmsprevious %f, col %d\n",meanprevious,mean,rms,rmsprevious,icol);
660               calROC->SetStatus(icol -1 ,irow, AliTRDCalPadStatus::kPadBridgedRight);
661               calROC->SetStatus(icol ,irow, AliTRDCalPadStatus::kPadBridgedLeft);
662             }       
663           }
664
665         }
666       }
667
668       delete calRocMean;
669       delete calRocRMS;
670       delete calRocMeand;
671       delete calRocRMSd;
672
673
674     }
675   
676   return obj;
677   
678 }
679 //_______________________________________________________________________________________
680 AliTRDCalPad* AliTRDCalibPadStatus::CreateCalPad()
681 {
682   //
683   // Create Pad Noise out of RMS values
684   //
685
686   AliTRDCalPad* obj = new AliTRDCalPad("PadNoise", "PadNoise");
687   
688   
689   for (Int_t det=0; det<AliTRDgeometry::kNdet; ++det)  {
690     
691     AliTRDCalROC *calROC22 = obj->GetCalROC(det);
692
693     AliTRDCalROC *calRocRMS     = ((AliTRDCalROC *)GetCalRocRMS(det,kTRUE));
694    
695     for(Int_t k = 0; k < calROC22->GetNchannels(); k++){
696       calROC22->SetValue(k,calRocRMS->GetValue(k));
697     }
698
699   }
700   
701   return obj;
702   
703 }
704
705 //_______________________________________________________________________________________
706 AliTRDCalDet* AliTRDCalibPadStatus::CreateCalDet() const
707 {
708   //
709   // Create Det Noise correction factor
710   //
711
712   AliTRDCalDet* obj = new AliTRDCalDet("DetNoise", "DetNoise (correction factor)");
713
714   for(Int_t l = 0; l < 540; l++){
715     obj->SetValue(l,10.0);
716   }
717   
718   return obj;
719   
720 }
721
722 //_____________________________________________________________________
723 void AliTRDCalibPadStatus::DumpToFile(const Char_t *filename, const Char_t *dir, Bool_t append) /*FOLD00*/
724 {
725     //
726     //  Write class to file
727     //
728
729     TString sDir(dir);
730     TString option;
731
732     if ( append )
733         option = "update";
734     else
735         option = "recreate";
736
737     TDirectory *backup = gDirectory;
738     TFile f(filename,option.Data());
739     f.cd();
740     if ( !sDir.IsNull() ){
741         f.mkdir(sDir.Data());
742         f.cd(sDir);
743     }
744     this->Write();
745     f.Close();
746
747     if ( backup ) backup->cd();
748 }
749
750 //_____________________________________________________________________
751 void AliTRDCalibPadStatus::SetCalRocMean(AliTRDCalROC *mean, Int_t det) /*FOLD00*/
752 {
753     //
754     //  Put the AliTRDCalROC in the array fCalRocArrayMean
755     //
756
757
758   AliTRDCalROC *rocMean = GetCalRocMean(det,kTRUE);
759   
760   Int_t nChannels = rocMean->GetNchannels();
761   
762   for (Int_t iChannel=0; iChannel<nChannels; iChannel++){
763     
764     rocMean->SetValue(iChannel,mean->GetValue(iChannel));
765     
766   }
767   
768 }
769
770 //_____________________________________________________________________
771 void AliTRDCalibPadStatus::SetCalRocRMS(AliTRDCalROC *rms, Int_t det) /*FOLD00*/
772 {
773     //
774     //  Put the AliTRDCalROC in the array fCalRocArrayRMS
775     //
776
777
778   AliTRDCalROC *rocRms = GetCalRocRMS(det,kTRUE);
779   
780   Int_t nChannels = rocRms->GetNchannels();
781   
782   for (Int_t iChannel=0; iChannel<nChannels; iChannel++){
783     
784     rocRms->SetValue(iChannel,rms->GetValue(iChannel));
785     
786   }
787   
788 }
789 //_____________________________________________________________________
790 void AliTRDCalibPadStatus::SetCalRocMeand(AliTRDCalROC *mean, Int_t det) /*FOLD00*/
791 {
792     //
793     //  Put the AliTRDCalROC in the array fCalRocArrayMean
794     //
795
796
797   AliTRDCalROC *rocMean = GetCalRocMeand(det,kTRUE);
798   
799   Int_t nChannels = rocMean->GetNchannels();
800   
801   for (Int_t iChannel=0; iChannel<nChannels; iChannel++){
802     
803     rocMean->SetValue(iChannel,mean->GetValue(iChannel));
804     
805   }
806   
807 }
808
809 //_____________________________________________________________________
810 void AliTRDCalibPadStatus::SetCalRocRMSd(AliTRDCalROC *rms, Int_t det) /*FOLD00*/
811 {
812     //
813     //  Put the AliTRDCalROC in the array fCalRocArrayRMS
814     //
815
816
817   AliTRDCalROC *rocRms = GetCalRocRMSd(det,kTRUE);
818   
819   Int_t nChannels = rocRms->GetNchannels();
820   
821   for (Int_t iChannel=0; iChannel<nChannels; iChannel++){
822     
823     rocRms->SetValue(iChannel,rms->GetValue(iChannel));
824     
825   }
826   
827 }
828 //_____________________________________________________________________________
829 Int_t AliTRDCalibPadStatus::GetLayer(Int_t d) const
830 {
831   //
832   // Reconstruct the layer number from the detector number
833   //
834
835   return ((Int_t) (d % 6));
836
837 }
838
839 //_____________________________________________________________________________
840 Int_t AliTRDCalibPadStatus::GetStack(Int_t d) const
841 {
842   //
843   // Reconstruct the chamber number from the detector number
844   //
845
846   return ((Int_t) (d % 30) / 6);
847
848 }
849
850 //_____________________________________________________________________________
851 Int_t AliTRDCalibPadStatus::GetSector(Int_t d) const
852 {
853   //
854   // Reconstruct the sector number from the detector number
855   //
856
857   return ((Int_t) (d / 30));
858
859 }
860
861