1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
18 ////////////////////////////////////////////////////////////////////////////
20 // Example: fill pedestal with Gaussian noise //
22 // AliTRDCalibPadStatus ped; //
23 // ped.TestEvent(numberofevent); //
25 // // Method without histo //
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) //
39 // TCanvas* c1 = new TCanvas; //
40 // c1->Divide(2,2); //
42 // histo2dm->Draw("colz"); //
44 // histo1dm->Draw(); //
46 // histo2ds->Draw("colz"); //
48 // histo1ds->Draw(); //
50 // // Method with histo //
51 // ped.AnalyseHisto(); //
53 // // Take the histo //
54 // TH1F *histo = ped.GetHisto(31); //
55 // histo->SetEntries(1); //
58 ////////////////////////////////////////////////////////////////////////////
61 #include <TObjArray.h>
66 #include <TDirectory.h>
70 #include <AliMathBase.h>
71 #include "AliRawReader.h"
72 #include "AliRawReaderRoot.h"
73 #include "AliRawReaderDate.h"
77 #include "AliTRDCalibPadStatus.h"
78 #include "AliTRDrawStreamBase.h"
79 #include "AliTRDgeometry.h"
80 #include "AliTRDCommonParam.h"
81 #include "./Cal/AliTRDCalROC.h"
82 #include "./Cal/AliTRDCalPadStatus.h"
83 #include "./Cal/AliTRDCalDet.h"
84 #include "./Cal/AliTRDCalPad.h"
85 #include "./Cal/AliTRDCalSingleChamberStatus.h"
91 ClassImp(AliTRDCalibPadStatus) /*FOLD00*/
93 //_____________________________________________________________________
94 AliTRDCalibPadStatus::AliTRDCalibPadStatus() : /*FOLD00*/
100 fNumberOfTimeBins(0),
101 fCalRocArrayMean(540),
102 fCalRocArrayRMS(540),
103 fCalRocArrayMeand(540),
104 fCalRocArrayRMSd(540),
108 // default constructor
111 fGeo = new AliTRDgeometry();
115 //_____________________________________________________________________
116 AliTRDCalibPadStatus::AliTRDCalibPadStatus(const AliTRDCalibPadStatus &ped) : /*FOLD00*/
119 fAdcMin(ped.GetAdcMin()),
120 fAdcMax(ped.GetAdcMax()),
121 fDetector(ped.fDetector),
122 fNumberOfTimeBins(ped.fNumberOfTimeBins),
123 fCalRocArrayMean(540),
124 fCalRocArrayRMS(540),
125 fCalRocArrayMeand(540),
126 fCalRocArrayRMSd(540),
132 for (Int_t idet = 0; idet < 540; idet++){
133 const AliTRDCalROC *calRocMean = (AliTRDCalROC*)ped.fCalRocArrayMean.UncheckedAt(idet);
134 const AliTRDCalROC *calRocRMS = (AliTRDCalROC*)ped.fCalRocArrayRMS.UncheckedAt(idet);
135 const AliTRDCalROC *calRocMeand = (AliTRDCalROC*)ped.fCalRocArrayMeand.UncheckedAt(idet);
136 const AliTRDCalROC *calRocRMSd = (AliTRDCalROC*)ped.fCalRocArrayRMSd.UncheckedAt(idet);
137 const TH2F *hped = (TH2F*)ped.fHistoArray.UncheckedAt(idet);
139 if ( calRocMean != 0x0 ) fCalRocArrayMean.AddAt(new AliTRDCalROC(*calRocMean), idet);
140 if ( calRocRMS != 0x0 ) fCalRocArrayRMS.AddAt(new AliTRDCalROC(*calRocRMS), idet);
142 if ( calRocMeand != 0x0 ) fCalRocArrayMeand.AddAt(new AliTRDCalROC(*calRocMeand), idet);
143 if ( calRocRMSd != 0x0 ) fCalRocArrayRMSd.AddAt(new AliTRDCalROC(*calRocRMSd), idet);
146 TH2F *hNew = new TH2F(*hped);
147 hNew->SetDirectory(0);
148 fHistoArray.AddAt(hNew,idet);
155 fGeo = new AliTRDgeometry();
158 //_____________________________________________________________________
159 AliTRDCalibPadStatus& AliTRDCalibPadStatus::operator = (const AliTRDCalibPadStatus &source)
162 // assignment operator
164 if (&source == this) return *this;
165 new (this) AliTRDCalibPadStatus(source);
170 //_____________________________________________________________________
171 AliTRDCalibPadStatus::~AliTRDCalibPadStatus() /*FOLD00*/
181 //_____________________________________________________________________
182 Int_t AliTRDCalibPadStatus::UpdateHisto(const Int_t icdet, /*FOLD00*/
191 // Signal filling methode
193 Int_t nbchannel = icRow+icCol*crowMax;
195 // now the case of double read channel
197 nbchannel = (((ccold-1)*8+ icMcm)*crowMax+icRow)+144*crowMax;
198 //printf("nbchannel %d, ccold %d, icMcm %d, crowMax %d, icRow %d\n",nbchannel,ccold,icMcm,crowMax,icRow);
201 // fast filling methode.
202 // Attention: the entry counter of the histogram is not increased
203 // this means that e.g. the colz draw option gives an empty plot
205 if ( !(((Int_t)csignal>fAdcMax ) || ((Int_t)csignal<fAdcMin)) )
206 bin = (nbchannel+1)*(fAdcMax-fAdcMin+2)+((Int_t)csignal-fAdcMin+1);
208 GetHisto(icdet,kTRUE)->GetArray()[bin]++;
212 //_____________________________________________________________________
213 Int_t AliTRDCalibPadStatus::ProcessEvent(AliTRDrawStreamBase *rawStream, Bool_t nocheck)
216 // Event Processing loop - AliTRDRawStreamCosmic
217 // 0 time bin problem or zero suppression
224 rawStream->SetSharedPadReadout(kTRUE);
227 while (rawStream->Next()) {
228 Int_t rawversion = rawStream->GetRawVersion(); // current raw version
229 //if(!rawStream->IsDataZeroSuppressed()) {
231 AliInfo(Form("this is not no-zero-suppressed data, the version is %d",rawversion));
234 Int_t idetector = rawStream->GetDet(); // current detector
235 Int_t iRow = rawStream->GetRow(); // current row
236 Int_t iRowMax = rawStream->GetMaxRow(); // current rowmax
237 Int_t iCol = rawStream->GetCol(); // current col
240 Int_t iADC = 21-rawStream->GetADC(); // current ADC
242 if(iADC == 1) col = 1;
244 col = TMath::Max(0,(Int_t)(iADC-19));
247 Int_t mcm = (Int_t)(iCol/18); // current group of 18 col pads
248 if(col > 1) mcm -= 1;
249 if(col ==1) mcm += 1;
251 //Bool_t shared = rawStream->IsCurrentPadShared();
252 //printf("ADC %d, iCol %d, col %d, mcm %d, shared %d\n",iADC,iCol,col,mcm,(Int_t)shared);
254 Int_t iTimeBin = rawStream->GetTimeBin(); // current time bin
255 Int_t *signal = rawStream->GetSignals(); // current ADC signal
256 Int_t nbtimebin = rawStream->GetNumberOfTimeBins(); // number of time bins read from data
258 if((fDetector != -1) && (nbtimebin != fNumberOfTimeBins)) {
259 AliInfo(Form("the number of time bins is %d, is different from the previous one %d",nbtimebin,fNumberOfTimeBins));
262 fNumberOfTimeBins = nbtimebin;
264 Int_t fin = TMath::Min(nbtimebin,(iTimeBin+3));
267 for(Int_t k = iTimeBin; k < fin; k++){
268 if(signal[n]>0) UpdateHisto(idetector,iRow,iCol,signal[n],iRowMax,col,mcm);
276 while (rawStream->Next()) {
277 Int_t idetector = rawStream->GetDet(); // current detector
278 Int_t iRow = rawStream->GetRow(); // current row
279 Int_t iRowMax = rawStream->GetMaxRow(); // current rowmax
280 Int_t iCol = rawStream->GetCol(); // current col
283 Int_t iADC = 21-rawStream->GetADC(); // current ADC
285 if(iADC == 1) col = 1;
287 col = TMath::Max(0,(Int_t)(iADC-19));
290 Int_t mcm = (Int_t)(iCol/18); // current group of 18 col pads
291 if(col > 1) mcm -= 1;
292 if(col ==1) mcm += 1;
294 Int_t iTimeBin = rawStream->GetTimeBin(); // current time bin
295 Int_t *signal = rawStream->GetSignals(); // current ADC signal
296 Int_t nbtimebin = rawStream->GetNumberOfTimeBins(); // number of time bins read from data
298 Int_t fin = TMath::Min(nbtimebin,(iTimeBin+3));
301 //printf("det %d, row %d, signal[0] %d, signal[1] %d, signal [2] %d\n", idetector, iRow, signal[0], signal[1], signal[2]);
303 for(Int_t k = iTimeBin; k < fin; k++){
305 UpdateHisto(idetector,iRow,iCol,signal[n],iRowMax,col,mcm);
306 //printf("Update with det %d, row %d, col %d, signal %d, rowmax %d, col %d, mcm %d\n",idetector,iRow,iCol,signal[n],iRowMax,col,mcm);
318 //_____________________________________________________________________
319 Int_t AliTRDCalibPadStatus::ProcessEvent(AliRawReader *rawReader, Bool_t nocheck)
322 // Event processing loop - AliRawReader
327 rawReader->Select("TRD");
329 AliTRDrawStreamBase *pstream = AliTRDrawStreamBase::GetRawStream(rawReader);
331 result = ProcessEvent(pstream, nocheck);
338 //_________________________________________________________________________
339 Int_t AliTRDCalibPadStatus::ProcessEvent(
341 eventHeaderStruct *event,
344 eventHeaderStruct* /*event*/,
351 // process date event
354 AliRawReader *rawReader = new AliRawReaderDate((void*)event);
355 Bool_t result=ProcessEvent(rawReader, nocheck);
359 Fatal("AliTRDCalibPadStatus", "this class was compiled without DATE");
365 //_____________________________________________________________________
366 Bool_t AliTRDCalibPadStatus::TestEventHisto(Int_t nevent, Int_t sm) /*FOLD00*/
370 // fill one oroc and one iroc with random gaus
375 for (Int_t ism=sm; ism<sm+1; 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 < fGeo->GetRowMax(ipl,ich,ism); irow++){
379 for(Int_t icol = 0; icol < fGeo->GetColMax(ipl); icol++){
380 for (Int_t iTimeBin=0; iTimeBin<(30*nevent); iTimeBin++){
381 Int_t signal=(Int_t)(gRandom->Gaus(10.0,1.2));
382 if ( signal>0 )UpdateHisto((ipl+ich*6+ism*6*5),irow,icol,signal,fGeo->GetRowMax(ipl,ich,ism),0,0);
392 //_____________________________________________________________________
393 TH2F* AliTRDCalibPadStatus::GetHisto(Int_t det, TObjArray *arr, /*FOLD00*/
394 Int_t nbinsY, Float_t ymin, Float_t ymax,
395 Char_t *type, Bool_t force)
398 // return pointer to histogram
399 // if force is true create a new histogram if it doesn't exist allready
401 if ( !force || arr->UncheckedAt(det) )
402 return (TH2F*)arr->UncheckedAt(det);
404 // if we are forced and histogram doesn't yes exist create it
405 Char_t name[255], title[255];
407 sprintf(name,"hCalib%s%.2d",type,det);
408 sprintf(title,"%s calibration histogram detector %.2d;ADC channel;Channel (pad)",type,det);
411 Int_t nbchannels = fGeo->GetRowMax(GetPlane(det),GetChamber(det),GetSector(det))*fGeo->GetColMax(GetPlane(det));
413 // we will add 3*8*rowMax channels at the end for the double counted
414 nbchannels += 3*8*(fGeo->GetRowMax(GetPlane(det),GetChamber(det),GetSector(det)));
417 // new histogram with calib information. One value for each pad!
418 TH2F* hist = new TH2F(name,title,
420 nbchannels,0,nbchannels
422 hist->SetDirectory(0);
423 arr->AddAt(hist,det);
427 //_____________________________________________________________________
428 TH2F* AliTRDCalibPadStatus::GetHisto(Int_t det, Bool_t force) /*FOLD00*/
431 // return pointer to histogram
432 // if force is true create a new histogram if it doesn't exist allready
434 TObjArray *arr = &fHistoArray;
435 return GetHisto(det, arr, fAdcMax-fAdcMin, fAdcMin, fAdcMax, "Pedestal", force);
438 //_____________________________________________________________________
439 AliTRDCalROC* AliTRDCalibPadStatus::GetCalRoc(Int_t det, TObjArray* arr, Bool_t force) /*FOLD00*/
442 // return pointer to ROC Calibration
443 // if force is true create a new AliTRDCalROC if it doesn't exist allready
445 if ( !force || arr->UncheckedAt(det) )
446 return (AliTRDCalROC*)arr->UncheckedAt(det);
448 // if we are forced and histogram doesn't yes exist create it
450 // new AliTRDCalROC. One value for each pad!
451 AliTRDCalROC *croc = new AliTRDCalROC(GetPlane(det),GetChamber(det));
452 arr->AddAt(croc,det);
455 //_____________________________________________________________________
456 AliTRDCalROC* AliTRDCalibPadStatus::GetCalRocMean(Int_t det, Bool_t force) /*FOLD00*/
459 // return pointer to Carge ROC Calibration
460 // if force is true create a new histogram if it doesn't exist allready
462 TObjArray *arr = &fCalRocArrayMean;
463 return GetCalRoc(det, arr, force);
466 //_____________________________________________________________________
467 AliTRDCalROC* AliTRDCalibPadStatus::GetCalRocRMS(Int_t det, Bool_t force) /*FOLD00*/
470 // return pointer to Carge ROC Calibration
471 // if force is true create a new histogram if it doesn't exist allready
473 TObjArray *arr = &fCalRocArrayRMS;
474 return GetCalRoc(det, arr, force);
476 //_____________________________________________________________________
477 AliTRDCalROC* AliTRDCalibPadStatus::GetCalRocMeand(Int_t det, Bool_t force) /*FOLD00*/
480 // return pointer to Carge ROC Calibration
481 // if force is true create a new histogram if it doesn't exist allready
483 TObjArray *arr = &fCalRocArrayMeand;
484 return GetCalRoc(det, arr, force);
487 //_____________________________________________________________________
488 AliTRDCalROC* AliTRDCalibPadStatus::GetCalRocRMSd(Int_t det, Bool_t force) /*FOLD00*/
491 // return pointer to Carge ROC Calibration
492 // if force is true create a new histogram if it doesn't exist allready
494 TObjArray *arr = &fCalRocArrayRMSd;
495 return GetCalRoc(det, arr, force);
498 //_____________________________________________________________________
499 void AliTRDCalibPadStatus::AnalyseHisto() /*FOLD00*/
502 // Calculate calibration constants
505 Int_t nbinsAdc = fAdcMax-fAdcMin;
513 for (Int_t idet=0; idet<540; idet++){
514 TH2F *hP = GetHisto(idet);
519 AliTRDCalROC *rocMean = GetCalRocMean(idet,kTRUE);
520 AliTRDCalROC *rocRMS = GetCalRocRMS(idet,kTRUE);
522 arrayHP = hP->GetArray();
523 Int_t nChannels = rocMean->GetNchannels();
525 for (Int_t iChannel=0; iChannel<nChannels; iChannel++){
526 Int_t offset = (nbinsAdc+2)*(iChannel+1)+1;
527 Double_t ret = AliMathBase::FitGaus(arrayHP+offset,nbinsAdc,fAdcMin,fAdcMax,¶m,&dummy);
528 // if the fitting failed set noise and pedestal to 0
529 if ((ret==-4) || (ret==-1) || (ret==-2)) {
533 if((param[1]/10.0) > 65534.0) param[1] = 0.0;
534 if((param[2]/10.0) > 65534.0) param[2] = 0.0;
535 rocMean->SetValue(iChannel,param[1]/10.0);
536 rocRMS->SetValue(iChannel,param[2]/10.0);
539 // here we analyse doubled read channels
541 AliTRDCalROC *rocMeand = GetCalRocMeand(idet,kTRUE);
542 AliTRDCalROC *rocRMSd = GetCalRocRMSd(idet,kTRUE);
544 Int_t nrows = rocMeand->GetNrows();
545 Int_t shift = 144*nrows;
546 Int_t total = shift+3*8*nrows;
548 for (Int_t iChannel=shift; iChannel<total; iChannel++){
549 Int_t offset = (nbinsAdc+2)*(iChannel+1)+1;
550 Double_t ret = AliMathBase::FitGaus(arrayHP+offset,nbinsAdc,fAdcMin,fAdcMax,¶m,&dummy);
551 // if the fitting failed set noise and pedestal to 0
552 if ((ret==-4) || (ret==-1) || (ret==-2)) {
556 if((param[1]/10.0) > 65534.0) param[1] = 0.0;
557 if((param[2]/10.0) > 65534.0) param[2] = 0.0;
559 // here we have to recalculate backward
560 Int_t nb = iChannel-shift;
561 Int_t row = nb%nrows;
562 Int_t j = (Int_t)(nb/nrows);
564 Int_t icol = (Int_t)(j/8);
566 Int_t finalcol = 18*imcm;
567 if(icol > 0) icol += 17;
571 Int_t channel = row+finalcol*nrows;
573 //printf("iChannel %d, nrows %d, finalcol %d, row %d, channel %d\n",iChannel,nrows,finalcol,row,channel);
574 if((finalcol < 0) || (finalcol >= 144)) continue;
576 rocMeand->SetValue(channel,param[1]/10.0);
577 rocRMSd->SetValue(channel,param[2]/10.0);
584 //_______________________________________________________________________________________
585 AliTRDCalPadStatus* AliTRDCalibPadStatus::CreateCalPadStatus()
588 // Create Pad Status out of Mean and RMS values
591 AliTRDCalPadStatus* obj = new AliTRDCalPadStatus("padstatus", "padstatus");
593 for (Int_t idet=0; idet<540; ++idet)
595 AliTRDCalSingleChamberStatus *calROC = obj->GetCalROC(idet);
598 AliTRDCalROC *calRocMean = ((AliTRDCalROC *)GetCalRocMean(idet));
599 AliTRDCalROC *calRocRMS = ((AliTRDCalROC *)GetCalRocRMS(idet));
601 //Take the stuff second chance
602 AliTRDCalROC *calRocMeand = ((AliTRDCalROC *)GetCalRocMeand(idet));
603 AliTRDCalROC *calRocRMSd = ((AliTRDCalROC *)GetCalRocRMSd(idet));
606 for(Int_t k = 0; k < calROC->GetNchannels(); k++){
607 calROC->SetStatus(k,AliTRDCalPadStatus::kMasked);
613 Int_t channels = calROC->GetNchannels();
615 Double_t rmsmean = calRocMean->GetRMS()*10.0;
616 Double_t meanmean = calRocMean->GetMean()*10.0;
617 Double_t meansquares = calRocRMS->GetMean()*10.0;
619 for(Int_t ich = 0; ich < channels; ich++){
621 Float_t mean = calRocMean->GetValue(ich)*10.0;
622 Float_t rms = calRocRMS->GetValue(ich)*10.0;
624 if((rms <= 0.0001) || (TMath::Abs(mean-meanmean)>(5*rmsmean)) || (TMath::Abs(rms)>(5.0*TMath::Abs(meansquares)))) {
625 // look at second chance
626 Float_t meand = calRocMeand->GetValue(ich)*10.0;
627 Float_t rmsd = calRocRMSd->GetValue(ich)*10.0;
629 if((rmsd <= 0.0001) || (TMath::Abs(meand-meanmean)>(5*rmsmean)) || (TMath::Abs(rmsd)>(5.0*TMath::Abs(meansquares)))) {
630 calROC->SetStatus(ich, AliTRDCalPadStatus::kMasked);
632 else calROC->SetStatus(ich, AliTRDCalPadStatus::kReadSecond);
641 //_______________________________________________________________________________________
642 AliTRDCalPad* AliTRDCalibPadStatus::CreateCalPad()
645 // Create Pad Noise out of RMS values
648 AliTRDCalPad* obj = new AliTRDCalPad("PadNoise", "PadNoise");
651 for (Int_t det=0; det<AliTRDgeometry::kNdet; ++det) {
653 AliTRDCalROC *calROC22 = obj->GetCalROC(det);
655 AliTRDCalROC *calRocRMS = ((AliTRDCalROC *)GetCalRocRMS(det,kTRUE));
657 for(Int_t k = 0; k < calROC22->GetNchannels(); k++){
658 calROC22->SetValue(k,calRocRMS->GetValue(k));
667 //_______________________________________________________________________________________
668 AliTRDCalDet* AliTRDCalibPadStatus::CreateCalDet() const
671 // Create Det Noise correction factor
674 AliTRDCalDet* obj = new AliTRDCalDet("DetNoise", "DetNoise (correction factor)");
676 for(Int_t l = 0; l < 540; l++){
677 obj->SetValue(l,10.0);
684 //_____________________________________________________________________
685 void AliTRDCalibPadStatus::DumpToFile(const Char_t *filename, const Char_t *dir, Bool_t append) /*FOLD00*/
688 // Write class to file
699 TDirectory *backup = gDirectory;
700 TFile f(filename,option.Data());
702 if ( !sDir.IsNull() ){
703 f.mkdir(sDir.Data());
709 if ( backup ) backup->cd();
712 //_____________________________________________________________________
713 void AliTRDCalibPadStatus::SetCalRocMean(AliTRDCalROC *mean, Int_t det) /*FOLD00*/
716 // Put the AliTRDCalROC in the array fCalRocArrayMean
720 AliTRDCalROC *rocMean = GetCalRocMean(det,kTRUE);
722 Int_t nChannels = rocMean->GetNchannels();
724 for (Int_t iChannel=0; iChannel<nChannels; iChannel++){
726 rocMean->SetValue(iChannel,mean->GetValue(iChannel));
732 //_____________________________________________________________________
733 void AliTRDCalibPadStatus::SetCalRocRMS(AliTRDCalROC *rms, Int_t det) /*FOLD00*/
736 // Put the AliTRDCalROC in the array fCalRocArrayRMS
740 AliTRDCalROC *rocRms = GetCalRocRMS(det,kTRUE);
742 Int_t nChannels = rocRms->GetNchannels();
744 for (Int_t iChannel=0; iChannel<nChannels; iChannel++){
746 rocRms->SetValue(iChannel,rms->GetValue(iChannel));
751 //_____________________________________________________________________
752 void AliTRDCalibPadStatus::SetCalRocMeand(AliTRDCalROC *mean, Int_t det) /*FOLD00*/
755 // Put the AliTRDCalROC in the array fCalRocArrayMean
759 AliTRDCalROC *rocMean = GetCalRocMeand(det,kTRUE);
761 Int_t nChannels = rocMean->GetNchannels();
763 for (Int_t iChannel=0; iChannel<nChannels; iChannel++){
765 rocMean->SetValue(iChannel,mean->GetValue(iChannel));
771 //_____________________________________________________________________
772 void AliTRDCalibPadStatus::SetCalRocRMSd(AliTRDCalROC *rms, Int_t det) /*FOLD00*/
775 // Put the AliTRDCalROC in the array fCalRocArrayRMS
779 AliTRDCalROC *rocRms = GetCalRocRMSd(det,kTRUE);
781 Int_t nChannels = rocRms->GetNchannels();
783 for (Int_t iChannel=0; iChannel<nChannels; iChannel++){
785 rocRms->SetValue(iChannel,rms->GetValue(iChannel));
790 //_____________________________________________________________________________
791 Int_t AliTRDCalibPadStatus::GetPlane(Int_t d) const
794 // Reconstruct the plane number from the detector number
797 return ((Int_t) (d % 6));
801 //_____________________________________________________________________________
802 Int_t AliTRDCalibPadStatus::GetChamber(Int_t d) const
805 // Reconstruct the chamber number from the detector number
808 return ((Int_t) (d % 30) / 6);
812 //_____________________________________________________________________________
813 Int_t AliTRDCalibPadStatus::GetSector(Int_t d) const
816 // Reconstruct the sector number from the detector number
819 return ((Int_t) (d / 30));