DCS DP with correct getters
[u/mrichter/AliRoot.git] / TPC / AliTPCCalibPedestal.cxx
CommitLineData
8bc7e885 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
8bc7e885 17/* $Id$ */
18
8bc7e885 19
20//Root includes
8bc7e885 21#include <TH1F.h>
8bc7e885 22#include <TH2F.h>
8bc7e885 23#include <TString.h>
8bc7e885 24#include <TMath.h>
25#include <TF1.h>
26#include <TRandom.h>
8bc7e885 27#include <TDirectory.h>
8bc7e885 28#include <TFile.h>
ac940b58 29#include <TMap.h>
8bc7e885 30//AliRoot includes
31#include "AliRawReader.h"
32#include "AliRawReaderRoot.h"
bc331d5b 33#include "AliRawReaderDate.h"
8bc7e885 34#include "AliTPCRawStream.h"
35#include "AliTPCCalROC.h"
8bc7e885 36#include "AliTPCROC.h"
8bc7e885 37#include "AliMathBase.h"
8bc7e885 38#include "TTreeStream.h"
4958b652 39#include "AliTPCRawStreamFast.h"
8bc7e885 40
bc331d5b 41//date
42#include "event.h"
43
44//header file
45#include "AliTPCCalibPedestal.h"
8bc7e885 46
47
aa983e4f 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//
1542c62d 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
aa983e4f 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");
aa983e4f 181*/
bdf99a93 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//
8bc7e885 199
200
aa983e4f 201ClassImp(AliTPCCalibPedestal)
8bc7e885 202
1542c62d 203AliTPCCalibPedestal::AliTPCCalibPedestal() :
880c3382 204 AliTPCCalibRawBase(),
8bc7e885 205 fAdcMin(1),
206 fAdcMax(100),
1542c62d 207 fAnaMeanDown(0.),
208 fAnaMeanUp(1.),
bdf99a93 209 fTimeAnalysis(kFALSE),
8bc7e885 210 fCalRocArrayPedestal(72),
1542c62d 211 fCalRocArraySigma(72),
bdf99a93 212 fHistoPedestalArray(72),
1542c62d 213 fTimeSignal(NULL),
214 fCalRocArrayMean(72),
215 fCalRocArrayRMS(72)
8bc7e885 216{
bdf99a93 217 //
218 // default constructor
219 //
880c3382 220 SetNameTitle("AliTPCCalibPedestal","AliTPCCalibPedestal");
221 fFirstTimeBin=60;
222 fLastTimeBin=1000;
8bc7e885 223}
bdf99a93 224
225
bc331d5b 226//_____________________________________________________________________
1542c62d 227AliTPCCalibPedestal::AliTPCCalibPedestal(const AliTPCCalibPedestal &ped) :
880c3382 228 AliTPCCalibRawBase(ped),
bc331d5b 229 fAdcMin(ped.GetAdcMin()),
230 fAdcMax(ped.GetAdcMax()),
1542c62d 231 fAnaMeanDown(ped.fAnaMeanDown),
232 fAnaMeanUp(ped.fAnaMeanUp),
bdf99a93 233 fTimeAnalysis(ped.fTimeAnalysis),
bc331d5b 234 fCalRocArrayPedestal(72),
1542c62d 235 fCalRocArraySigma(72),
bdf99a93 236 fHistoPedestalArray(72),
1542c62d 237 fTimeSignal(ped.fTimeSignal),
238 fCalRocArrayMean(72),
239 fCalRocArrayRMS(72)
bc331d5b 240{
bdf99a93 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);
bc331d5b 256 }
bdf99a93 257 }
bc331d5b 258}
ac940b58 259AliTPCCalibPedestal::AliTPCCalibPedestal(const TMap *config):
880c3382 260 AliTPCCalibRawBase(),
ac940b58 261 fAdcMin(1),
262 fAdcMax(100),
263 fAnaMeanDown(0.),
264 fAnaMeanUp(1.),
265 fTimeAnalysis(kFALSE),
ac940b58 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 //
880c3382 276 SetNameTitle("AliTPCCalibPedestal","AliTPCCalibPedestal");
277 fFirstTimeBin=60;
278 fLastTimeBin=1000;
ac940b58 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());
ac940b58 284}
bdf99a93 285
286
bc331d5b 287//_____________________________________________________________________
288AliTPCCalibPedestal& AliTPCCalibPedestal::operator = (const AliTPCCalibPedestal &source)
289{
290 //
291 // assignment operator
292 //
293 if (&source == this) return *this;
294 new (this) AliTPCCalibPedestal(source);
8bc7e885 295
bc331d5b 296 return *this;
297}
bdf99a93 298
299
8bc7e885 300//_____________________________________________________________________
1542c62d 301AliTPCCalibPedestal::~AliTPCCalibPedestal()
8bc7e885 302{
303 //
304 // destructor
305 //
8bc7e885 306
bdf99a93 307 fCalRocArrayPedestal.Delete();
308 fCalRocArrayRMS.Delete();
a480de15 309 fCalRocArraySigma.Delete();
bdf99a93 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 }
4958b652 320
321 // do not delete fMapping, because we do not own it.
322
bdf99a93 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 }
aa983e4f 355}
bdf99a93 356
357
8bc7e885 358//_____________________________________________________________________
1542c62d 359Int_t AliTPCCalibPedestal::Update(const Int_t icsector,
bdf99a93 360 const Int_t icRow,
361 const Int_t icPad,
362 const Int_t icTimeBin,
363 const Float_t csignal)
8bc7e885 364{
bdf99a93 365 //
366 // Signal filling method
367 //
b401648b 368 if (icRow<0) return 0;
369 if (icPad<0) return 0;
370 if (icTimeBin<0) return 0;
371
bdf99a93 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;
8bc7e885 382
bdf99a93 383 Int_t iChannel = fROC->GetRowIndexes(icsector)[icRow]+icPad; // global pad position in sector
8bc7e885 384
4958b652 385 // fast filling method
bdf99a93 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);
8bc7e885 389
bdf99a93 390 GetHistoPedestal(icsector,kTRUE)->GetArray()[bin]++;
8bc7e885 391
bdf99a93 392 return 0;
8bc7e885 393}
4958b652 394
395
08205ed7 396//_____________________________________________________________________
1542c62d 397Bool_t AliTPCCalibPedestal::TestEvent()
8bc7e885 398{
399 //
400 // Test event loop
bc331d5b 401 // fill one oroc and one iroc with random gaus
8bc7e885 402 //
403
880c3382 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 }
8bc7e885 415 }
880c3382 416 }
417 return kTRUE;
8bc7e885 418}
bdf99a93 419
420
8bc7e885 421//_____________________________________________________________________
1542c62d 422TH2F* AliTPCCalibPedestal::GetHisto(Int_t sector, TObjArray *arr,
4958b652 423 Int_t nbinsY, Float_t ymin, Float_t ymax,
a6e0ebfe 424 const Char_t *type, Bool_t force)
8bc7e885 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) )
bc331d5b 431 return (TH2F*)arr->UncheckedAt(sector);
8bc7e885 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);
bc331d5b 437 sprintf(title,"%s calibration histogram sector %.2d;ADC channel;Channel (pad)",type,sector);
8bc7e885 438
439 // new histogram with Q calib information. One value for each pad!
bc331d5b 440 TH2F* hist = new TH2F(name,title,
8bc7e885 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}
bdf99a93 448
449
8bc7e885 450//_____________________________________________________________________
1542c62d 451TH2F* AliTPCCalibPedestal::GetHistoPedestal(Int_t sector, Bool_t force)
8bc7e885 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}
bdf99a93 460
461
8bc7e885 462//_____________________________________________________________________
1542c62d 463AliTPCCalROC* AliTPCCalibPedestal::GetCalRoc(Int_t sector, TObjArray* arr, Bool_t force)
8bc7e885 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
aa983e4f 472 // if we are forced and the histogram doesn't yet exist create it
8bc7e885 473
474 // new AliTPCCalROC for T0 information. One value for each pad!
475 AliTPCCalROC *croc = new AliTPCCalROC(sector);
8bc7e885 476 arr->AddAt(croc,sector);
477 return croc;
478}
bdf99a93 479
480
8bc7e885 481//_____________________________________________________________________
1542c62d 482AliTPCCalROC* AliTPCCalibPedestal::GetCalRocPedestal(Int_t sector, Bool_t force)
8bc7e885 483{
484 //
1542c62d 485 // return pointer to ROC with Pedestal data
8bc7e885 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}
bdf99a93 491
492
8bc7e885 493//_____________________________________________________________________
1542c62d 494AliTPCCalROC* AliTPCCalibPedestal::GetCalRocSigma(Int_t sector, Bool_t force)
8bc7e885 495{
496 //
1542c62d 497 // return pointer to ROC with signal witdth in sigma
8bc7e885 498 // if force is true create a new histogram if it doesn't exist allready
499 //
1542c62d 500 TObjArray *arr = &fCalRocArraySigma;
8bc7e885 501 return GetCalRoc(sector, arr, force);
502}
1542c62d 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}
bdf99a93 524
525
8bc7e885 526//_____________________________________________________________________
aa983e4f 527void AliTPCCalibPedestal::Merge(AliTPCCalibPedestal *ped)
528{
bdf99a93 529 //
530 // Merge reference histograms of sig to the current AliTPCCalibSignal
531 //
aa983e4f 532
bdf99a93 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 }
aa983e4f 549
bdf99a93 550 // merge array
551 // ...
aa983e4f 552
aa983e4f 553}
bdf99a93 554
555
aa983e4f 556//_____________________________________________________________________
1542c62d 557void AliTPCCalibPedestal::Analyse()
8bc7e885 558{
bdf99a93 559 //
560 // Calculate calibration constants
561 //
8bc7e885 562
bdf99a93 563 Int_t nbinsAdc = fAdcMax-fAdcMin;
8bc7e885 564
1542c62d 565 TVectorD param(4);
bdf99a93 566 TMatrixD dummy(3,3);
8bc7e885 567
1542c62d 568 TH1F *hChannel=new TH1F("hChannel","hChannel",nbinsAdc,fAdcMin,fAdcMax);
569
bdf99a93 570 Float_t *array_hP=0;
8bc7e885 571
bdf99a93 572 for (Int_t iSec=0; iSec<72; ++iSec){
573 TH2F *hP = GetHistoPedestal(iSec);
574 if ( !hP ) continue;
8bc7e885 575
bdf99a93 576 AliTPCCalROC *rocPedestal = GetCalRocPedestal(iSec,kTRUE);
1542c62d 577 AliTPCCalROC *rocSigma = GetCalRocSigma(iSec,kTRUE);
578 AliTPCCalROC *rocMean = GetCalRocMean(iSec,kTRUE);
bdf99a93 579 AliTPCCalROC *rocRMS = GetCalRocRMS(iSec,kTRUE);
8bc7e885 580
bdf99a93 581 array_hP = hP->GetArray();
582 UInt_t nChannels = fROC->GetNChannels(iSec);
8bc7e885 583
bdf99a93 584 for (UInt_t iChannel=0; iChannel<nChannels; ++iChannel){
585 Int_t offset = (nbinsAdc+2)*(iChannel+1)+1;
1542c62d 586 //calculate mean and sigma using a gaus fit
9e359afd 587 //Double_t ret =
588 AliMathBase::FitGaus(array_hP+offset,nbinsAdc,fAdcMin,fAdcMax,&param,&dummy);
bdf99a93 589 // if the fitting failed set noise and pedestal to 0
1542c62d 590 // is now done in AliMathBase::FitGaus !
591// if ( ret == -4 ) {
592// param[1]=0;
593// param[2]=0;
594// }
ac940b58 595 if ( param[1]<fAdcMin || param[1]>fAdcMax ){
596 param[1]=0;
597 param[2]=0;
598 }
bdf99a93 599 rocPedestal->SetValue(iChannel,param[1]);
1542c62d 600 rocSigma->SetValue(iChannel,param[2]);
601 //calculate mean and RMS using a truncated means
602 hChannel->Set(nbinsAdc+2,array_hP+offset-1);
603 hChannel->SetEntries(param[3]);
604 param[1]=0;
605 param[2]=0;
606 if ( param[3]>0 ) AliMathBase::TruncatedMean(hChannel,&param,fAnaMeanDown,fAnaMeanUp);
607 rocMean->SetValue(iChannel,param[1]);
bdf99a93 608 rocRMS->SetValue(iChannel,param[2]);
609 }
610 }
1542c62d 611 delete hChannel;
bdf99a93 612}
8bc7e885 613
bdf99a93 614
615//_____________________________________________________________________
616void AliTPCCalibPedestal::AnalyseTime(Int_t nevents)
617{
618 //
619 // Calculate for each channel and time bin the mean pedestal. This
620 // is used on LDC by TPCPEDESTALda to generate data used for configuration
621 // of the pattern memory for baseline subtraction in the ALTROs.
622 //
623
624 if ( nevents <= 0 ) return;
625 if ( fTimeAnalysis ) {
626 for (Int_t i = 0; i < 159; i++) { // padrows
627 for (Int_t j = 0; j < 140; j++) { // pads per row
628 for (Int_t k = 0; k < 1024; k++) { // time bins per pad
629 fTimeSignal[i][j].AddAt(fTimeSignal[i][j].At(k)/(Float_t)nevents, k);
8bc7e885 630 }
bdf99a93 631 }
8bc7e885 632 }
bdf99a93 633 }
8bc7e885 634}