TRD/AliTRDCalibPadStatus.cxx

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