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