TRD/AliTRDCalibPadStatus.cxx

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