Update TPCCEda to write output file in parts (to avoid too big files produced in...
[u/mrichter/AliRoot.git] / TPC / AliTPCCalibPedestal.cxx
... / ...
CommitLineData
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
17/* $Id$ */
18
19
20//Root includes
21#include <TH1F.h>
22#include <TH2F.h>
23#include <TString.h>
24#include <TMath.h>
25#include <TF1.h>
26#include <TRandom.h>
27#include <TDirectory.h>
28#include <TFile.h>
29#include <TMap.h>
30//AliRoot includes
31#include "AliRawReader.h"
32#include "AliRawReaderRoot.h"
33#include "AliRawReaderDate.h"
34#include "AliTPCRawStream.h"
35#include "AliTPCCalROC.h"
36#include "AliTPCROC.h"
37#include "AliMathBase.h"
38#include "TTreeStream.h"
39#include "AliTPCRawStreamFast.h"
40
41//date
42#include "event.h"
43
44//header file
45#include "AliTPCCalibPedestal.h"
46
47
48///////////////////////////////////////////////////////////////////////////////////////
49// Implementation of the TPC pedestal and noise calibration
50//
51// Origin: Jens Wiechula, Marian Ivanov J.Wiechula@gsi.de, Marian.Ivanov@cern.ch
52//
53//
54// *************************************************************************************
55// * Class Description *
56// *************************************************************************************
57//
58// Working principle:
59// ------------------
60// Raw pedestal data is processed by calling one of the ProcessEvent(...) functions
61// (see below). These in the end call the Update(...) function, where the data is filled
62// into histograms.
63//
64// For each ROC one TH2F histo (ROC channel vs. ADC channel) is created when
65// it is filled for the first time (GetHistoPedestal(ROC,kTRUE)). All histos are stored in the
66// TObjArray fHistoPedestalArray.
67//
68// For a fast filling of the histogram the corresponding bin number of the channel and ADC channel
69// is computed by hand and the histogram array is accessed directly via its pointer.
70// ATTENTION: Doing so the the entry counter of the histogram is not increased
71// this means that e.g. the colz draw option gives an empty plot unless
72// calling 'histo->SetEntries(1)' before drawing.
73//
74// After accumulating the desired statistics the Analyse() function has to be called.
75// Whithin this function the pedestal and noise values are calculated for each pad, using
76// the fast gaus fit function AliMathBase::FitGaus(...), and the calibration
77// storage classes (AliTPCCalROC) are filled for each ROC.
78// The calibration information is stored in the TObjArrays fCalRocArrayPedestal and fCalRocArrayRMS;
79//
80//
81//
82// User interface for filling data:
83// --------------------------------
84//
85// To Fill information one of the following functions can be used:
86//
87// Bool_t ProcessEvent(eventHeaderStruct *event);
88// - process Date event
89// - use AliTPCRawReaderDate and call ProcessEvent(AliRawReader *rawReader)
90//
91// Bool_t ProcessEvent(AliRawReader *rawReader);
92// - process AliRawReader event
93// - use AliTPCRawStream to loop over data and call ProcessEvent(AliTPCRawStream *rawStream)
94//
95// Bool_t ProcessEvent(AliTPCRawStream *rawStream);
96// - process event from AliTPCRawStream
97// - call Update function for signal filling
98//
99// Int_t Update(const Int_t isector, const Int_t iRow, const Int_t
100// iPad, const Int_t iTimeBin, const Float_t signal);
101// - directly fill signal information (sector, row, pad, time bin, pad)
102// to the reference histograms
103//
104// It is also possible to merge two independently taken calibrations using the function
105//
106// void Merge(AliTPCCalibPedestal *ped)
107// - copy histograms in 'ped' if the do not exist in this instance
108// - Add histograms in 'ped' to the histograms in this instance if the allready exist
109// - After merging call Analyse again!
110//
111//
112//
113// -- example: filling data using root raw data:
114// void fillPedestal(Char_t *filename)
115// {
116// rawReader = new AliRawReaderRoot(fileName);
117// if ( !rawReader ) return;
118// AliTPCCalibPedestal *calib = new AliTPCCalibPedestal;
119// while (rawReader->NextEvent()){
120// calib->ProcessEvent(rawReader);
121// }
122// calib->Analyse();
123// calib->DumpToFile("PedestalData.root");
124// delete rawReader;
125// delete calib;
126// }
127//
128//
129// What kind of information is stored and how to retrieve them:
130// ------------------------------------------------------------
131//
132// - Accessing the 'Reference Histograms' (pedestal distribution histograms):
133//
134// TH2F *GetHistoPedestal(Int_t sector);
135//
136// - Accessing the calibration storage objects:
137//
138// AliTPCCalROC *GetCalRocPedestal(Int_t sector); - for the pedestal values, mean from gaus fit
139// AliTPCCalROC *GetCalRocSigma(Int_t sector); - for the Noise values, sigma from guas fit
140// AliTPCCalROC *GetCalRocMean(Int_t sector); - for the pedestal values, truncated mean
141// AliTPCCalROC *GetCalRocRMS(Int_t sector); - for the Noise values, rms from truncated mean
142//
143// example for visualisation:
144// if the file "PedestalData.root" was created using the above example one could do the following:
145//
146// TFile filePedestal("PedestalData.root")
147// AliTPCCalibPedestal *ped = (AliTPCCalibPedestal*)filePedestal->Get("AliTPCCalibPedestal");
148// ped->GetCalRocPedestal(0)->Draw("colz");
149// ped->GetCalRocRMS(0)->Draw("colz");
150//
151// or use the AliTPCCalPad functionality:
152// AliTPCCalPad padPedestal(ped->GetCalPadPedestal());
153// AliTPCCalPad padNoise(ped->GetCalPadRMS());
154// padPedestal->MakeHisto2D()->Draw("colz"); //Draw A-Side Pedestal Information
155// padNoise->MakeHisto2D()->Draw("colz"); //Draw A-Side Noise Information
156//
157/*
158 example: fill pedestal with gausschen noise
159 AliTPCCalibPedestal ped;
160 ped.TestEvent();
161 ped.Analyse();
162 //Draw output;
163 TCanvas* c1 = new TCanvas;
164 c1->Divide(1,2);
165 c1->cd(1);
166 ped.GetHistoPedestal(0)->SetEntries(1); //needed in order for colz to work, reason: fast filling does not increase the entries counter
167 ped.GetHistoPedestal(0)->Draw("colz");
168 c1->cd(2);
169 ped.GetHistoPedestal(36)->SetEntries(1); //needed in order for colz to work, reason: fast filling does not increase the entries counter
170 ped.GetHistoPedestal(36)->Draw("colz");
171 TCanvas* c2 = new TCanvas;
172 c2->Divide(2,2);
173 c2->cd(1);
174 ped.GetCalRocPedestal(0)->Draw("colz");
175 c2->cd(2);
176 ped.GetCalRocRMS(0)->Draw("colz");
177 c2->cd(3);
178 ped.GetCalRocPedestal(36)->Draw("colz");
179 c2->cd(4);
180 ped.GetCalRocRMS(36)->Draw("colz");
181*/
182//
183// Time dependent pedestals:
184//
185// If wished there is the possibility to calculate for each channel and time bin
186// the mean pedestal [pedestals(t)]. This is done by
187//
188// 1) setting SetTimeAnalysis(kTRUE),
189// 2) processing the data by looping over the events using ProcessEvent(..)
190// 3) calling the Analyse() and AnalyseTime(nevents) functions (providing nevents)
191// 4) getting the pedestals(t) using TArrayF **timePed = calibPedestal.GetTimePedestals();
192// 5) looking at values using timePed[row][pad].At(timebin)
193//
194// This functionality is intended to be used on an LDC bu the detector algorithm
195// (TPCPEDESTALda) to generate a data set used for configuration of the pattern
196// memory for baseline subtraction in the ALTROs. Later the information should also
197// be stored as reference data.
198//
199
200
201ClassImp(AliTPCCalibPedestal)
202
203AliTPCCalibPedestal::AliTPCCalibPedestal() :
204 AliTPCCalibRawBase(),
205 fAdcMin(1),
206 fAdcMax(100),
207 fAnaMeanDown(0.),
208 fAnaMeanUp(1.),
209 fTimeAnalysis(kFALSE),
210 fCalRocArrayPedestal(72),
211 fCalRocArraySigma(72),
212 fHistoPedestalArray(72),
213 fTimeSignal(NULL),
214 fCalRocArrayMean(72),
215 fCalRocArrayRMS(72)
216{
217 //
218 // default constructor
219 //
220 SetNameTitle("AliTPCCalibPedestal","AliTPCCalibPedestal");
221 fFirstTimeBin=60;
222 fLastTimeBin=1000;
223}
224
225
226//_____________________________________________________________________
227AliTPCCalibPedestal::AliTPCCalibPedestal(const AliTPCCalibPedestal &ped) :
228 AliTPCCalibRawBase(ped),
229 fAdcMin(ped.GetAdcMin()),
230 fAdcMax(ped.GetAdcMax()),
231 fAnaMeanDown(ped.fAnaMeanDown),
232 fAnaMeanUp(ped.fAnaMeanUp),
233 fTimeAnalysis(ped.fTimeAnalysis),
234 fCalRocArrayPedestal(72),
235 fCalRocArraySigma(72),
236 fHistoPedestalArray(72),
237 fTimeSignal(ped.fTimeSignal),
238 fCalRocArrayMean(72),
239 fCalRocArrayRMS(72)
240{
241 //
242 // copy constructor
243 //
244 for (Int_t iSec = 0; iSec < 72; ++iSec){
245 const AliTPCCalROC *calPed = (AliTPCCalROC*)ped.fCalRocArrayPedestal.UncheckedAt(iSec);
246 const AliTPCCalROC *calRMS = (AliTPCCalROC*)ped.fCalRocArrayRMS.UncheckedAt(iSec);
247 const TH2F *hPed = (TH2F*)ped.fHistoPedestalArray.UncheckedAt(iSec);
248
249 if ( calPed != 0x0 ) fCalRocArrayPedestal.AddAt(new AliTPCCalROC(*calPed), iSec);
250 if ( calRMS != 0x0 ) fCalRocArrayRMS.AddAt(new AliTPCCalROC(*calRMS), iSec);
251
252 if ( hPed != 0x0 ){
253 TH2F *hNew = new TH2F(*hPed);
254 hNew->SetDirectory(0);
255 fHistoPedestalArray.AddAt(hNew,iSec);
256 }
257 }
258}
259AliTPCCalibPedestal::AliTPCCalibPedestal(const TMap *config):
260 AliTPCCalibRawBase(),
261 fAdcMin(1),
262 fAdcMax(100),
263 fAnaMeanDown(0.),
264 fAnaMeanUp(1.),
265 fTimeAnalysis(kFALSE),
266 fCalRocArrayPedestal(72),
267 fCalRocArraySigma(72),
268 fHistoPedestalArray(72),
269 fTimeSignal(NULL),
270 fCalRocArrayMean(72),
271 fCalRocArrayRMS(72)
272{
273 //
274 // This constructor uses a TMap for setting some parametes
275 //
276 SetNameTitle("AliTPCCalibPedestal","AliTPCCalibPedestal");
277 fFirstTimeBin=60;
278 fLastTimeBin=1000;
279 if (config->GetValue("FirstTimeBin")) fFirstTimeBin = ((TObjString*)config->GetValue("FirstTimeBin"))->GetString().Atoi();
280 if (config->GetValue("LastTimeBin")) fLastTimeBin = ((TObjString*)config->GetValue("LastTimeBin"))->GetString().Atoi();
281 if (config->GetValue("AdcMin")) fAdcMin = ((TObjString*)config->GetValue("AdcMin"))->GetString().Atoi();
282 if (config->GetValue("AdcMax")) fAdcMax = ((TObjString*)config->GetValue("AdcMax"))->GetString().Atoi();
283 if (config->GetValue("TimeAnalysis")) SetTimeAnalysis(((TObjString*)config->GetValue("TimeAnalysis"))->GetString().Atoi());
284}
285
286
287//_____________________________________________________________________
288AliTPCCalibPedestal& AliTPCCalibPedestal::operator = (const AliTPCCalibPedestal &source)
289{
290 //
291 // assignment operator
292 //
293 if (&source == this) return *this;
294 new (this) AliTPCCalibPedestal(source);
295
296 return *this;
297}
298
299
300//_____________________________________________________________________
301AliTPCCalibPedestal::~AliTPCCalibPedestal()
302{
303 //
304 // destructor
305 //
306
307 fCalRocArrayPedestal.Delete();
308 fCalRocArrayRMS.Delete();
309 fCalRocArraySigma.Delete();
310 fHistoPedestalArray.Delete();
311
312 if ( fTimeSignal ) {
313 for (Int_t i = 0; i < 159; i++) {
314 delete [] fTimeSignal[i];
315 fTimeSignal[i] = 0;
316 }
317 delete [] fTimeSignal;
318 fTimeSignal = 0;
319 }
320
321 // do not delete fMapping, because we do not own it.
322
323}
324
325
326//_____________________________________________________________________
327void AliTPCCalibPedestal::SetTimeAnalysis(Bool_t time)
328{
329 //
330 // Use time dependent analysis: Pedestals are analysed as a function
331 // of the drift time. There is one mean value generated for each time
332 // bin and each channel. It can be used as reference data and for
333 // configuration of the ALTRO pattern memory for baseline subtraction.
334 //
335 // ATTENTION: Use only on LDC in TPCPEDESTALda! On a LDC we get data
336 // only from one sector. For the full TPC we would need a lot of
337 // memory (36*159*140*1024*4bytes = 3.3GB)!
338 //
339
340 fTimeAnalysis = time;
341
342 if ( !fTimeAnalysis ) return;
343
344 // prepare array for one sector (159*140*1024*4bytes = 92MB):
345 fTimeSignal = new TArrayF*[159];
346 for (Int_t i = 0; i < 159; i++) { // padrows
347 fTimeSignal[i] = new TArrayF[140];
348 for (Int_t j = 0; j < 140; j++) { // pads per row
349 fTimeSignal[i][j].Set(1024);
350 for (Int_t k = 0; k < 1024; k++) { // time bins per pad
351 fTimeSignal[i][j].AddAt(0., k);
352 }
353 }
354 }
355}
356
357
358//_____________________________________________________________________
359Int_t AliTPCCalibPedestal::Update(const Int_t icsector,
360 const Int_t icRow,
361 const Int_t icPad,
362 const Int_t icTimeBin,
363 const Float_t csignal)
364{
365 //
366 // Signal filling method
367 //
368 if (icRow<0) return 0;
369 if (icPad<0) return 0;
370 if (icTimeBin<0) return 0;
371
372 // Time dependent pedestals
373 if ( fTimeAnalysis ) {
374 if ( icsector < 36 ) // IROC
375 fTimeSignal[icRow][icPad].AddAt(fTimeSignal[icRow][icPad].At(icTimeBin)+csignal, icTimeBin);
376 else
377 fTimeSignal[icRow+63][icPad].AddAt(fTimeSignal[icRow+63][icPad].At(icTimeBin)+csignal, icTimeBin);
378 }
379 //return if we are out of the specified time bin or adc range
380 if ( (icTimeBin>fLastTimeBin) || (icTimeBin<fFirstTimeBin) ) return 0;
381 if ( ((Int_t)csignal>fAdcMax) || ((Int_t)csignal<fAdcMin) ) return 0;
382
383 Int_t iChannel = fROC->GetRowIndexes(icsector)[icRow]+icPad; // global pad position in sector
384
385 // fast filling method
386 // Attention: the entry counter of the histogram is not increased
387 // this means that e.g. the colz draw option gives an empty plot
388 Int_t bin = (iChannel+1)*(fAdcMax-fAdcMin+2)+((Int_t)csignal-fAdcMin+1);
389
390 GetHistoPedestal(icsector,kTRUE)->GetArray()[bin]++;
391
392 return 0;
393}
394
395
396//_____________________________________________________________________
397Bool_t AliTPCCalibPedestal::TestEvent()
398{
399 //
400 // Test event loop
401 // fill one oroc and one iroc with random gaus
402 //
403
404 gRandom->SetSeed(0);
405
406 for (UInt_t iSec=0; iSec<72; ++iSec){
407 if (iSec%36>0) continue;
408 for (UInt_t iRow=0; iRow < fROC->GetNRows(iSec); ++iRow){
409 for (UInt_t iPad=0; iPad < fROC->GetNPads(iSec,iRow); ++iPad){
410 for (UInt_t iTimeBin=0; iTimeBin<1024; ++iTimeBin){
411 Float_t signal=(Int_t)(iRow+3+gRandom->Gaus(0,.7));
412 if ( signal>0 )Update(iSec,iRow,iPad,iTimeBin,signal);
413 }
414 }
415 }
416 }
417 return kTRUE;
418}
419
420
421//_____________________________________________________________________
422TH2F* AliTPCCalibPedestal::GetHisto(Int_t sector, TObjArray *arr,
423 Int_t nbinsY, Float_t ymin, Float_t ymax,
424 const Char_t *type, Bool_t force)
425{
426 //
427 // return pointer to Q histogram
428 // if force is true create a new histogram if it doesn't exist allready
429 //
430 if ( !force || arr->UncheckedAt(sector) )
431 return (TH2F*)arr->UncheckedAt(sector);
432
433 // if we are forced and histogram doesn't yes exist create it
434 Char_t name[255], title[255];
435
436 sprintf(name,"hCalib%s%.2d",type,sector);
437 sprintf(title,"%s calibration histogram sector %.2d;ADC channel;Channel (pad)",type,sector);
438
439 // new histogram with Q calib information. One value for each pad!
440 TH2F* hist = new TH2F(name,title,
441 nbinsY, ymin, ymax,
442 fROC->GetNChannels(sector),0,fROC->GetNChannels(sector)
443 );
444 hist->SetDirectory(0);
445 arr->AddAt(hist,sector);
446 return hist;
447}
448
449
450//_____________________________________________________________________
451TH2F* AliTPCCalibPedestal::GetHistoPedestal(Int_t sector, Bool_t force)
452{
453 //
454 // return pointer to T0 histogram
455 // if force is true create a new histogram if it doesn't exist allready
456 //
457 TObjArray *arr = &fHistoPedestalArray;
458 return GetHisto(sector, arr, fAdcMax-fAdcMin, fAdcMin, fAdcMax, "Pedestal", force);
459}
460
461
462//_____________________________________________________________________
463AliTPCCalROC* AliTPCCalibPedestal::GetCalRoc(Int_t sector, TObjArray* arr, Bool_t force)
464{
465 //
466 // return pointer to ROC Calibration
467 // if force is true create a new histogram if it doesn't exist allready
468 //
469 if ( !force || arr->UncheckedAt(sector) )
470 return (AliTPCCalROC*)arr->UncheckedAt(sector);
471
472 // if we are forced and the histogram doesn't yet exist create it
473
474 // new AliTPCCalROC for T0 information. One value for each pad!
475 AliTPCCalROC *croc = new AliTPCCalROC(sector);
476 arr->AddAt(croc,sector);
477 return croc;
478}
479
480
481//_____________________________________________________________________
482AliTPCCalROC* AliTPCCalibPedestal::GetCalRocPedestal(Int_t sector, Bool_t force)
483{
484 //
485 // return pointer to ROC with Pedestal data
486 // if force is true create a new histogram if it doesn't exist allready
487 //
488 TObjArray *arr = &fCalRocArrayPedestal;
489 return GetCalRoc(sector, arr, force);
490}
491
492
493//_____________________________________________________________________
494AliTPCCalROC* AliTPCCalibPedestal::GetCalRocSigma(Int_t sector, Bool_t force)
495{
496 //
497 // return pointer to ROC with signal witdth in sigma
498 // if force is true create a new histogram if it doesn't exist allready
499 //
500 TObjArray *arr = &fCalRocArraySigma;
501 return GetCalRoc(sector, arr, force);
502}
503//_____________________________________________________________________
504AliTPCCalROC* AliTPCCalibPedestal::GetCalRocMean(Int_t sector, Bool_t force)
505{
506 //
507 // return pointer to ROC with signal mean information
508 // if force is true create a new histogram if it doesn't exist allready
509 //
510 TObjArray *arr = &fCalRocArrayMean;
511 return GetCalRoc(sector, arr, force);
512}
513
514//_____________________________________________________________________
515AliTPCCalROC* AliTPCCalibPedestal::GetCalRocRMS(Int_t sector, Bool_t force)
516{
517 //
518 // return pointer to signal width ROC Calibration
519 // if force is true create a new histogram if it doesn't exist allready
520 //
521 TObjArray *arr = &fCalRocArrayRMS;
522 return GetCalRoc(sector, arr, force);
523}
524
525
526//_____________________________________________________________________
527void AliTPCCalibPedestal::Merge(AliTPCCalibPedestal * const ped)
528{
529 //
530 // Merge reference histograms of sig to the current AliTPCCalibSignal
531 //
532 MergeBase(ped);
533 // merge histograms
534 for (Int_t iSec=0; iSec<72; ++iSec){
535 TH2F *hRefPedMerge = ped->GetHistoPedestal(iSec);
536
537 if ( hRefPedMerge ){
538 TDirectory *dir = hRefPedMerge->GetDirectory(); hRefPedMerge->SetDirectory(0);
539 TH2F *hRefPed = GetHistoPedestal(iSec);
540 if ( hRefPed ) hRefPed->Add(hRefPedMerge);
541 else {
542 TH2F *hist = new TH2F(*hRefPedMerge);
543 hist->SetDirectory(0);
544 fHistoPedestalArray.AddAt(hist, iSec);
545 }
546 hRefPedMerge->SetDirectory(dir);
547 }
548 }
549
550 // merge array
551 // ...
552
553}
554
555//_____________________________________________________________________
556Long64_t AliTPCCalibPedestal::Merge(TCollection * const list)
557{
558 //
559 // Merge all objects of this type in list
560 //
561
562 Long64_t nmerged=1;
563
564 TIter next(list);
565 AliTPCCalibPedestal *ce=0;
566 TObject *o=0;
567
568 while ( (o=next()) ){
569 ce=dynamic_cast<AliTPCCalibPedestal*>(o);
570 if (ce){
571 Merge(ce);
572 ++nmerged;
573 }
574 }
575
576 return nmerged;
577}
578
579//_____________________________________________________________________
580void AliTPCCalibPedestal::Analyse()
581{
582 //
583 // Calculate calibration constants
584 //
585
586 Int_t nbinsAdc = fAdcMax-fAdcMin;
587
588 TVectorD param(4);
589 TMatrixD dummy(3,3);
590
591 TH1F *hChannel=new TH1F("hChannel","hChannel",nbinsAdc,fAdcMin,fAdcMax);
592
593 Float_t *arrayhP=0;
594
595 for (Int_t iSec=0; iSec<72; ++iSec){
596 TH2F *hP = GetHistoPedestal(iSec);
597 if ( !hP ) continue;
598
599 AliTPCCalROC *rocPedestal = GetCalRocPedestal(iSec,kTRUE);
600 AliTPCCalROC *rocSigma = GetCalRocSigma(iSec,kTRUE);
601 AliTPCCalROC *rocMean = GetCalRocMean(iSec,kTRUE);
602 AliTPCCalROC *rocRMS = GetCalRocRMS(iSec,kTRUE);
603
604 arrayhP = hP->GetArray();
605 UInt_t nChannels = fROC->GetNChannels(iSec);
606
607 for (UInt_t iChannel=0; iChannel<nChannels; ++iChannel){
608 Int_t offset = (nbinsAdc+2)*(iChannel+1)+1;
609 //calculate mean and sigma using a gaus fit
610 //Double_t ret =
611 AliMathBase::FitGaus(arrayhP+offset,nbinsAdc,fAdcMin,fAdcMax,&param,&dummy);
612 // if the fitting failed set noise and pedestal to 0
613 // is now done in AliMathBase::FitGaus !
614// if ( ret == -4 ) {
615// param[1]=0;
616// param[2]=0;
617// }
618 if ( param[1]<fAdcMin || param[1]>fAdcMax ){
619 param[1]=0;
620 param[2]=0;
621 }
622 rocPedestal->SetValue(iChannel,param[1]);
623 rocSigma->SetValue(iChannel,param[2]);
624 //calculate mean and RMS using a truncated means
625 hChannel->Set(nbinsAdc+2,arrayhP+offset-1);
626 hChannel->SetEntries(param[3]);
627 param[1]=0;
628 param[2]=0;
629 if ( param[3]>0 ) AliMathBase::TruncatedMean(hChannel,&param,fAnaMeanDown,fAnaMeanUp);
630 rocMean->SetValue(iChannel,param[1]);
631 rocRMS->SetValue(iChannel,param[2]);
632 }
633 }
634 delete hChannel;
635}
636
637
638//_____________________________________________________________________
639void AliTPCCalibPedestal::AnalyseTime(Int_t nevents)
640{
641 //
642 // Calculate for each channel and time bin the mean pedestal. This
643 // is used on LDC by TPCPEDESTALda to generate data used for configuration
644 // of the pattern memory for baseline subtraction in the ALTROs.
645 //
646
647 if ( nevents <= 0 ) return;
648 if ( fTimeAnalysis ) {
649 for (Int_t i = 0; i < 159; i++) { // padrows
650 for (Int_t j = 0; j < 140; j++) { // pads per row
651 for (Int_t k = 0; k < 1024; k++) { // time bins per pad
652 fTimeSignal[i][j].AddAt(fTimeSignal[i][j].At(k)/(Float_t)nevents, k);
653 }
654 }
655 }
656 }
657}