Made the fEquipmentID variable constant
[u/mrichter/AliRoot.git] / TPC / AliTPCCalibPedestal.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
17 //-------------------------------------------------------
18 //          Implementation of the TPC pedestal and noise calibration
19 //
20 //   Origin: Jens Wiechula, Marian Ivanov   J.Wiechula@gsi.de, Marian.Ivanov@cern.ch
21 // 
22 // 
23 //-------------------------------------------------------
24
25
26 /* $Id$ */
27
28
29
30 //Root includes
31 #include <TObjArray.h>
32 #include <TH1F.h>
33 #include <TH1D.h>
34 #include <TH2F.h>
35 #include <TH2S.h>
36 #include <TH1S.h>
37 #include <TString.h>
38 #include <TVectorF.h>
39 #include <TMath.h>
40 #include <TF1.h>
41 #include <TRandom.h>
42 #include <TROOT.h>
43 #include <TDirectory.h>
44 #include <TSystem.h>
45 #include <TFile.h>
46
47
48 //AliRoot includes
49 #include "AliRawReader.h"
50 #include "AliRawReaderRoot.h"
51 #include "AliTPCRawStream.h"
52 #include "AliTPCCalROC.h"
53 #include "AliTPCCalPad.h"
54 #include "AliTPCROC.h"
55 #include "AliTPCCalibPedestal.h"
56 #include "AliMathBase.h"
57
58 #include "TTreeStream.h"
59
60
61
62 ClassImp(AliTPCCalibPedestal) /*FOLD00*/
63
64
65
66
67
68
69
70 AliTPCCalibPedestal::AliTPCCalibPedestal() : /*FOLD00*/
71   TObject(),
72   fFirstTimeBin(60),
73   fLastTimeBin(1000),
74   fAdcMin(1),
75   fAdcMax(100),
76   fROC(AliTPCROC::Instance()),
77   fCalRocArrayPedestal(72),
78   fCalRocArrayRMS(72),
79   fHistoPedestalArray(72),
80   fDebugStreamer(0),
81   fDebugLevel(0)
82 {
83     //
84     // AliTPCSignal default constructor
85     //
86     //debug stream
87     TDirectory *backup = gDirectory;
88     fDebugStreamer = new TTreeSRedirector("deb2.root");
89     if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer    
90 }
91
92 //_____________________________________________________________________
93 AliTPCCalibPedestal::~AliTPCCalibPedestal() /*FOLD00*/
94 {
95   //
96   // destructor
97   //
98     if ( fDebugStreamer ) delete fDebugStreamer;
99     delete fROC;
100 }
101
102
103
104
105 //_____________________________________________________________________
106 Int_t AliTPCCalibPedestal::Update(const Int_t icsector, /*FOLD00*/
107                                 const Int_t icRow,
108                                 const Int_t icPad,
109                                 const Int_t icTimeBin,
110                                 const Float_t csignal)
111 {
112     //
113     // Signal filling methode 
114     //
115     if ( (icTimeBin>fLastTimeBin) || (icTimeBin<fFirstTimeBin)   ) return 0;
116
117     Int_t iChannel  = fROC->GetRowIndexes(icsector)[icRow]+icPad; //  global pad position in sector
118
119     // dirty and fast filling methode. No boundary checking!!!
120     // Attention: the entry counter of the histogram is not increased
121     //            this means that e.g. the colz draw option gives an empty plot
122     Int_t bin = (iChannel+1)*(fAdcMax-fAdcMin+2)+((Int_t)csignal-fAdcMin+1);
123
124     GetHistoPedestal(icsector,kTRUE)->GetArray()[bin]++;
125
126     return 0;
127 }
128 //_____________________________________________________________________
129 Bool_t AliTPCCalibPedestal::ProcessEvent(AliRawReader *rawReader) /*FOLD00*/
130 {
131   //
132   //  simple event processing loop
133   //
134
135
136     AliTPCRawStream input(rawReader);
137
138   rawReader->Select("TPC");
139
140   input.SetOldRCUFormat(1);
141   printf("start event processing\n");
142
143
144   Bool_t withInput = kFALSE;
145
146   while (input.Next()) {
147
148       Int_t isector  = input.GetSector();                       //  current sector
149       Int_t iRow     = input.GetRow();                          //  current row
150       Int_t iPad     = input.GetPad();                          //  current pad
151       Int_t iTimeBin = input.GetTime();                         //  current time bin
152       Float_t signal = input.GetSignal();                       //  current ADC signal
153
154       Update(isector,iRow,iPad,iTimeBin,signal);
155       withInput = kTRUE;
156   }
157
158   printf("end event processing\n");
159   if ( fDebugLevel>0 )
160       fDebugStreamer->GetFile()->Write();
161   return withInput;
162 }
163 //_____________________________________________________________________
164 Bool_t AliTPCCalibPedestal::TestEvent() /*FOLD00*/
165 {
166   //
167   //  Test event loop
168   //
169
170     gRandom->SetSeed(0);
171
172     for (UInt_t iSec=0; iSec<72; iSec++){
173         if (iSec%36>0) continue;
174         for (UInt_t iRow=0; iRow < fROC->GetNRows(iSec); iRow++){
175             for (UInt_t iPad=0; iPad < fROC->GetNPads(iSec,iRow); iPad++){
176                 for (UInt_t iTimeBin=0; iTimeBin<1024; iTimeBin++){
177                     Float_t signal=(Int_t)(iRow+5+gRandom->Gaus(0,.7));
178                     if ( signal>0 )Update(iSec,iRow,iPad,iTimeBin,signal);
179                 }
180             }
181         }
182     }
183     return kTRUE;
184 }
185 //_____________________________________________________________________
186 TH2S* AliTPCCalibPedestal::GetHisto(Int_t sector, TObjArray *arr, /*FOLD00*/
187                                   Int_t nbinsY, Float_t ymin, Float_t ymax,
188                                   Char_t *type, Bool_t force)
189 {
190     //
191     // return pointer to Q histogram
192     // if force is true create a new histogram if it doesn't exist allready
193     //
194     if ( !force || arr->UncheckedAt(sector) )
195         return (TH2S*)arr->UncheckedAt(sector);
196
197     // if we are forced and histogram doesn't yes exist create it
198     Char_t name[255], title[255];
199
200     sprintf(name,"hCalib%s%.2d",type,sector);
201     sprintf(title,"%s calibration histogram sector %.2d",type,sector);
202
203     // new histogram with Q calib information. One value for each pad!
204     TH2S* hist = new TH2S(name,title,
205                           nbinsY, ymin, ymax,
206                           fROC->GetNChannels(sector),0,fROC->GetNChannels(sector)
207                          );
208     hist->SetDirectory(0);
209     arr->AddAt(hist,sector);
210     return hist;
211 }
212 //_____________________________________________________________________
213 TH2S* AliTPCCalibPedestal::GetHistoPedestal(Int_t sector, Bool_t force) /*FOLD00*/
214 {
215     //
216     // return pointer to T0 histogram
217     // if force is true create a new histogram if it doesn't exist allready
218     //
219     TObjArray *arr = &fHistoPedestalArray;
220     return GetHisto(sector, arr, fAdcMax-fAdcMin, fAdcMin, fAdcMax, "Pedestal", force);
221 }
222 //_____________________________________________________________________
223 AliTPCCalROC* AliTPCCalibPedestal::GetCalRoc(Int_t sector, TObjArray* arr, Bool_t force) /*FOLD00*/
224 {
225     //
226     // return pointer to ROC Calibration
227     // if force is true create a new histogram if it doesn't exist allready
228     //
229     if ( !force || arr->UncheckedAt(sector) )
230         return (AliTPCCalROC*)arr->UncheckedAt(sector);
231
232     // if we are forced and histogram doesn't yes exist create it
233
234     // new AliTPCCalROC for T0 information. One value for each pad!
235     AliTPCCalROC *croc = new AliTPCCalROC(sector);
236     //init values
237     for ( UInt_t iChannel = 0; iChannel<croc->GetNchannels(); iChannel++){
238         croc->SetValue(iChannel, 0);
239     }
240     arr->AddAt(croc,sector);
241     return croc;
242 }
243 //_____________________________________________________________________
244 AliTPCCalROC* AliTPCCalibPedestal::GetCalRocPedestal(Int_t sector, Bool_t force) /*FOLD00*/
245 {
246     //
247     // return pointer to Carge ROC Calibration
248     // if force is true create a new histogram if it doesn't exist allready
249     //
250     TObjArray *arr = &fCalRocArrayPedestal;
251     return GetCalRoc(sector, arr, force);
252 }
253 //_____________________________________________________________________
254 AliTPCCalROC* AliTPCCalibPedestal::GetCalRocRMS(Int_t sector, Bool_t force) /*FOLD00*/
255 {
256     //
257     // return pointer to signal width ROC Calibration
258     // if force is true create a new histogram if it doesn't exist allready
259     //
260     TObjArray *arr = &fCalRocArrayRMS;
261     return GetCalRoc(sector, arr, force);
262 }
263 //_____________________________________________________________________
264 void AliTPCCalibPedestal::Analyse() /*FOLD00*/
265 {
266     //
267     //  Calculate calibration constants
268     //
269
270     Int_t nbinsAdc = fAdcMax-fAdcMin;
271
272     TH1F *py = new TH1F("htemp_py","htemp_py", nbinsAdc, fAdcMin, fAdcMax);
273     TF1 *gaus = new TF1("fit","gaus");
274     TVectorD param(3);
275
276     Float_t *array_py=0;
277     Short_t *array_hP=0;
278
279     array_py = py->GetArray();
280
281     for (Int_t iSec=0; iSec<72; iSec++){
282         TH2S *hP = GetHistoPedestal(iSec);
283         if ( !hP ) continue;
284
285         AliTPCCalROC *rocPedestal = GetCalRocPedestal(iSec,kTRUE);
286         AliTPCCalROC *rocRMS      = GetCalRocRMS(iSec,kTRUE);
287
288         array_hP = hP->GetArray();
289         UInt_t nChannels = fROC->GetNChannels(iSec);
290
291         for (UInt_t iChannel=0; iChannel<nChannels; iChannel++){
292
293             // set bin content of py in a dirty but fast way
294             for (Int_t iAdc=0;iAdc<nbinsAdc;iAdc++)
295                 array_py[iAdc+1] = (Float_t)array_hP[(iChannel+1)*(nbinsAdc+2)+(iAdc+1)];
296
297             gaus->SetParameters(0,0);
298             py->Fit(gaus,"nq");
299
300             rocPedestal->SetValue(iChannel,gaus->GetParameter(1));
301             rocRMS->SetValue(iChannel,gaus->GetParameter(2));
302
303             //AliMathBase::FitGaus(nbinsAdc,array_hP+(iChannel+1)*(nbinsAdc+2),&param)
304             //rocPedestal->SetValue(iChannel,param[1]);
305             //rocRMS->SetValue(iChannel,param[2]);
306         }
307     }
308     delete py;
309     delete gaus;
310     delete fDebugStreamer;
311     fDebugStreamer = 0x0;
312 }
313 //_____________________________________________________________________
314 void AliTPCCalibPedestal::DumpToFile(const Char_t *filename, const Char_t *dir, Bool_t append) /*FOLD00*/
315 {
316     //
317     //  Write class to file
318     //
319
320     TDirectory *backup = gDirectory;
321     TString sDir(dir);
322     TString option;
323
324     if ( append )
325         option = "update";
326     else
327         option = "recreate";
328
329     TFile f(filename,option.Data());
330     if ( !sDir.IsNull() ){
331         f.mkdir(sDir.Data());
332         f.cd(sDir);
333     }
334     gDirectory->WriteTObject(this);
335     f.Close();
336
337     if ( backup ) backup->cd();
338
339 }