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