Corrected UInt_t <-> Int_t conversion
[u/mrichter/AliRoot.git] / TPC / AliTPCMonitor.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 $Log$
18 Revision 1.3  2007/10/12 13:36:27  cvetan
19 Coding convention fixes from Stefan
20
21 Revision 1.2  2007/09/18 09:44:45  cvetan
22 Sorting out some issues concerning the compilation with and without DATE support
23
24 Revision 1.1  2007/09/17 10:23:31  cvetan
25 New TPC monitoring package from Stefan Kniege. The monitoring package can be started by running TPCMonitor.C macro located in macros folder.
26
27 */   
28
29 ////////////////////////////////////////////////////////////////////////
30 ////
31 //// AliTPCMonitor class
32 //// 
33 //// Main class for TPC Monitor
34 //// Monitor can handle rootified data, files and online streams in DATE format.
35 //// The monitor GUI is started by the macro TPCMonitor.C
36 //// 
37 //// In the The data are read in in two read cycles. 
38 //// If no sector is specified (sectorid==-1) all sectors are read and only the max value 
39 //// for each channel is stored in a global histogram for Side A and C.
40 //// In this way the whole TPC can be read in at once.
41 ////
42 //// If the sector is specified  only one sector is read in and additional quantities
43 //// e.g baseline and baseline rms are calculated and stored. 
44 //// 
45 //// Author: Stefan Kniege, IKF, Frankfurt
46 ////       
47 ////
48 /////////////////////////////////////////////////////////////////////////
49
50
51
52 #include "AliLog.h"
53 #include "AliTPCMonitor.h"   
54 #include "AliTPCMonitorMappingHandler.h"
55 #include "AliTPCMonitorFFT.h"
56 #include "AliRawReader.h"
57 #include "AliRawReaderRoot.h"
58 #include "AliRawEventHeaderBase.h"
59 #include "AliAltroRawStreamV3.h"
60 #include "TH2F.h" 
61 #include "TF1.h"
62 #include "TMath.h"
63 #include "TCanvas.h"
64 #include "TH3S.h"
65 #include "TLegend.h"
66 #include "TROOT.h" 
67 #include "TDirectory.h"
68 #include "TSystem.h"
69 #include "TString.h"
70 #include "TPaveText.h"   
71 #include "TFile.h"
72 #include <Riostream.h>
73
74 ClassImp(AliTPCMonitor)
75
76 const Int_t AliTPCMonitor::fgkHwMaskFEC              = 0x0780;                          
77 const Int_t AliTPCMonitor::fgkHwMaskBranch           = 0x0800;                          
78 const Int_t AliTPCMonitor::fgkHwMaskFECChannel       = 0x007f;                          
79 const Int_t AliTPCMonitor::fgkHwMaskAltroChannel     = 0x000f;                          
80 const Int_t AliTPCMonitor::fgkHwMaskAltroChip        = 0x0070;                          
81 const Int_t AliTPCMonitor::fgkHwMaskRCU              = 0x7000;                          
82
83 //____________________________________________________________________________
84 AliTPCMonitor::AliTPCMonitor(char* name, char* title) : 
85 AliTPCMonitorConfig(name,title),
86 fPad(new Int_t*[GetMaxHwAddr()]),
87 fPadMapHw(new Float_t[GetMaxHwAddr()]),
88 fPadMapRCU(new Int_t*[GetMaxHwAddr()]),
89 fHistIROC(0),
90 fHistOROC(0),
91 fHistIROCIndex(0),
92 fHistOROCIndex(0),
93 fHistIROCTime(0),
94 fHistOROCTime(0),
95 fHistIROCClone(0),
96 fHistOROCClone(0),
97 fHistIROCRMS(0),
98 fHistOROCRMS(0),
99 fHistIROCBASE(0),
100 fHistOROCBASE(0),
101 fHistIROCSUM(0),
102 fHistOROCSUM(0),
103 fHistChannelTime(0),
104 fHistAddrMapIndex(0),
105 fHistAddrMaxAdc(0),
106 fHistAddrBaseMean(0),
107 fHistAddrMaxAdcX(0),
108 fHistAddrAdcSum(0),
109 fHistAddrBaseRms(0),
110 fHistDistrSumIROC(0),
111 fHistDistrMaxIROC(0),
112 fHistDistrSumOROC(0),
113 fHistDistrMaxOROC(0),
114 fHistDistrBase2dIROC(0),
115 fHistDistrBase2dOROC(0),
116 fHistDistrBaseRmsIROC(0),
117 fHistDistrBaseMeanIROC(0),
118 fHistDistrBaseRmsOROC(0),
119 fHistDistrBaseMeanOROC(0),
120 fHistGlobalMaxA(0),
121 fHistGlobalMaxC(0),
122 fHistList(new TObjArray()),
123
124 fkNRowsIroc(63),
125 fkNRowsOroc(96),
126
127 fkNPadsIroc(110),
128 fkNPadsOroc(140),
129 fkNPadMinIroc(-55),
130 fkNPadMinOroc(-70),
131 fkNPadMaxIroc(55),
132 fkNPadMaxOroc(70),
133 fVerb(0),
134 fLastEv(0),
135 fEventNumber(0),
136 fEventNumberOld(0),
137 fDisableFit(0),
138 fExecGlob(0),
139 fExecPlaneMax(0),
140 fExecPadIrocRms(0),
141 fExecPadOrocRms(0),
142 fRunId(0),
143 fEqId(0),
144 fPadUsedRoc(-1),
145 fPadUsedHwAddr(-1),
146 fGdcId(0),
147 fLdcId(0),
148 fLdcIdOld(1),
149 fMapEqidsSec(new Int_t*[36]),
150 fMapEqidsRcu(new Int_t[1000]),
151 fMirror(1),
152 fChannelIter(0),
153 fMapHand(0),
154 fRawReader(0)
155 {
156   // Constructor
157   
158   for(Int_t i = 0; i<GetMaxHwAddr(); i++) { fPad[i]       = new Int_t[GetTimeBins()];}
159   for(Int_t i = 0; i<GetMaxHwAddr(); i++) { fPadMapRCU[i] = new Int_t[6];}
160   for(Int_t i = 0; i<36; i++) { fMapEqidsSec[i]       = new Int_t[6];}
161   
162   if (gDirectory)
163   {
164     if (!gDirectory->GetList())
165     {
166       Warning("Build","Current directory is not a valid directory");
167       return;
168     }
169     AliTPCMonitor *hold = (AliTPCMonitor*)gDirectory->GetList()->FindObject(GetName());
170     if(hold)
171     {
172       Warning("Build","Replacing existing histogram: %s (Potential memory leak).",GetName());
173       gDirectory->GetList()->Remove(hold);
174     }
175     gDirectory->Append(this);
176   }
177   CreateHistos();
178   SetEqIds();
179   
180 }
181
182 //____________________________________________________________________________
183 AliTPCMonitor::AliTPCMonitor(const AliTPCMonitor &monitor):
184 AliTPCMonitorConfig(monitor.GetName(),monitor.GetTitle()),
185 fPad(new Int_t*[GetMaxHwAddr()]),
186 fPadMapHw(new Float_t[GetMaxHwAddr()]),
187 fPadMapRCU(new Int_t*[GetMaxHwAddr()]),
188 fHistIROC(0),
189 fHistOROC(0),
190 fHistIROCIndex(0),
191 fHistOROCIndex(0),
192 fHistIROCTime(0),
193 fHistOROCTime(0),
194 fHistIROCClone(0),
195 fHistOROCClone(0),
196 fHistIROCRMS(0),
197 fHistOROCRMS(0),
198 fHistIROCBASE(0),
199 fHistOROCBASE(0),
200 fHistIROCSUM(0),
201 fHistOROCSUM(0),
202 fHistChannelTime(0),
203 fHistAddrMapIndex(0),
204 fHistAddrMaxAdc(0),
205 fHistAddrBaseMean(0),
206 fHistAddrMaxAdcX(0),
207 fHistAddrAdcSum(0),
208 fHistAddrBaseRms(0),
209 fHistDistrSumIROC(0),
210 fHistDistrMaxIROC(0),
211 fHistDistrSumOROC(0),
212 fHistDistrMaxOROC(0),
213 fHistDistrBase2dIROC(0),
214 fHistDistrBase2dOROC(0),
215 fHistDistrBaseRmsIROC(0),
216 fHistDistrBaseMeanIROC(0),
217 fHistDistrBaseRmsOROC(0),
218 fHistDistrBaseMeanOROC(0),
219 fHistGlobalMaxA(0),
220 fHistGlobalMaxC(0),
221 fHistList(new TObjArray()),
222 fkNRowsIroc(monitor.fkNRowsIroc),
223 fkNRowsOroc(monitor.fkNRowsOroc),
224 fkNPadsIroc(monitor.fkNPadsIroc),
225 fkNPadsOroc(monitor.fkNPadsOroc),
226 fkNPadMinIroc(monitor.fkNPadMinIroc),
227 fkNPadMinOroc(monitor.fkNPadMinOroc),
228 fkNPadMaxIroc(monitor.fkNPadMaxIroc),
229 fkNPadMaxOroc(monitor.fkNPadMaxOroc),
230 fVerb(monitor.fVerb),
231 fLastEv(monitor.fLastEv),
232 fEventNumber(monitor.fEventNumber),
233 fEventNumberOld(monitor.fEventNumberOld),
234 fDisableFit(monitor.fDisableFit),
235 fExecGlob(monitor.fExecGlob),
236 fExecPlaneMax(monitor.fExecPlaneMax),
237 fExecPadIrocRms(monitor.fExecPadIrocRms),
238 fExecPadOrocRms(monitor.fExecPadOrocRms),
239 fRunId(monitor.fRunId),
240 fEqId(monitor.fEqId),
241 fPadUsedRoc(monitor.fPadUsedRoc),
242 fPadUsedHwAddr(monitor.fPadUsedHwAddr),
243 fGdcId(monitor.fGdcId),
244 fLdcId(monitor.fLdcId),
245 fLdcIdOld(monitor.fLdcIdOld),
246 fMapEqidsSec(new Int_t*[36]),
247 fMapEqidsRcu(new Int_t[1000]),
248 fMirror(monitor.fMirror),
249 fChannelIter(monitor.fChannelIter),
250 fMapHand(monitor.fMapHand),
251 fRawReader(monitor.fRawReader)
252 {
253   // copy constructor
254   
255   fHistIROC=(TH2F*)monitor.fHistIROC->Clone(); fHistList->Add(fHistIROC);
256   fHistOROC=(TH2F*)monitor.fHistOROC->Clone(); fHistList->Add(fHistOROC);
257   fHistIROCIndex=(TH2S*)monitor.fHistIROCIndex->Clone(); fHistList->Add(fHistIROCIndex);
258   fHistOROCIndex=(TH2S*)monitor.fHistOROCIndex->Clone(); fHistList->Add(fHistOROCIndex);
259   fHistIROCTime=(TH2F*)monitor.fHistIROCTime->Clone(); fHistList->Add(fHistIROCTime);
260   fHistOROCTime=(TH2F*)monitor.fHistOROCTime->Clone(); fHistList->Add(fHistOROCTime);
261   fHistIROCClone=(TH2F*)monitor.fHistIROCClone->Clone(); fHistList->Add(fHistIROCClone);
262   fHistOROCClone=(TH2F*)monitor.fHistOROCClone->Clone(); fHistList->Add(fHistOROCClone);
263   fHistIROCRMS=(TH2F*)monitor.fHistIROCRMS->Clone(); fHistList->Add(fHistIROCRMS);
264   fHistOROCRMS=(TH2F*)monitor.fHistOROCRMS->Clone(); fHistList->Add(fHistOROCRMS);
265   fHistIROCBASE=(TH2F*)monitor.fHistIROCBASE->Clone(); fHistList->Add(fHistIROCBASE);
266   fHistOROCBASE=(TH2F*)monitor.fHistOROCBASE->Clone(); fHistList->Add(fHistOROCBASE);
267   fHistIROCSUM=(TH2F*)monitor.fHistIROCSUM->Clone(); fHistList->Add(fHistIROCSUM);
268   fHistOROCSUM=(TH2F*)monitor.fHistOROCSUM->Clone(); fHistList->Add(fHistOROCSUM);
269   
270   fHistChannelTime=(TH2F*)monitor.fHistChannelTime->Clone(); fHistList->Add(fHistChannelTime);
271   
272   fHistAddrMapIndex=(TH1F*)monitor.fHistAddrMapIndex->Clone(); fHistList->Add(fHistAddrMapIndex);
273   fHistAddrMaxAdc=(TH1F*)monitor.fHistAddrMaxAdc->Clone(); fHistList->Add(fHistAddrMaxAdc);
274   fHistAddrBaseMean=(TH1F*)monitor.fHistAddrBaseMean->Clone(); fHistList->Add(fHistAddrBaseMean);
275   fHistAddrMaxAdcX=(TH1F*)monitor.fHistAddrMaxAdcX->Clone(); fHistList->Add(fHistAddrMaxAdcX);
276   fHistAddrAdcSum=(TH1F*)monitor.fHistAddrAdcSum->Clone(); fHistList->Add(fHistAddrAdcSum);
277   fHistAddrBaseRms=(TH1F*)monitor.fHistAddrBaseRms->Clone(); fHistList->Add(fHistAddrBaseRms);
278   
279   
280   fHistDistrSumIROC=(TH1F*)monitor.fHistDistrSumIROC->Clone(); fHistList->Add(fHistDistrSumIROC);
281   fHistDistrMaxIROC=(TH1F*)monitor.fHistDistrMaxIROC->Clone(); fHistList->Add(fHistDistrMaxIROC);
282   fHistDistrSumOROC=(TH1F*)monitor.fHistDistrSumOROC->Clone(); fHistList->Add(fHistDistrSumOROC);
283   fHistDistrMaxOROC=(TH1F*)monitor.fHistDistrMaxOROC->Clone(); fHistList->Add(fHistDistrMaxOROC);
284   
285   fHistDistrBase2dIROC=(TH2F*)monitor.fHistDistrBase2dIROC->Clone(); fHistList->Add(fHistDistrBase2dIROC);
286   fHistDistrBase2dOROC=(TH2F*)monitor.fHistDistrBase2dOROC->Clone(); fHistList->Add(fHistDistrBase2dOROC);
287   fHistDistrBaseRmsIROC=(TH1D*)monitor.fHistDistrBaseRmsIROC->Clone(); fHistList->Add(fHistDistrBaseRmsIROC);
288   fHistDistrBaseMeanIROC=(TH1D*)monitor.fHistDistrBaseMeanIROC->Clone(); fHistList->Add(fHistDistrBaseMeanIROC);
289   fHistDistrBaseRmsOROC=(TH1D*)monitor.fHistDistrBaseRmsOROC->Clone(); fHistList->Add(fHistDistrBaseRmsOROC);
290   fHistDistrBaseMeanOROC=(TH1D*)monitor.fHistDistrBaseMeanOROC->Clone(); fHistList->Add(fHistDistrBaseMeanOROC);
291   
292   fHistGlobalMaxA=(TH2S*)monitor.fHistGlobalMaxA->Clone(); fHistList->Add(fHistGlobalMaxA);
293   fHistGlobalMaxC=(TH2S*)monitor.fHistGlobalMaxC->Clone(); fHistList->Add(fHistGlobalMaxC);
294   
295   // fPad       = new Int_t*[monitor.GetMaxHwAddr()];
296   for(Int_t i = 0; i<GetMaxHwAddr(); i++) { fPad[i]       = new Int_t[monitor.GetTimeBins()];}
297   
298   //fPadMapRCU = new Int_t*[monitor.GetMaxHwAddr()];
299   for(Int_t i = 0; i<monitor.GetMaxHwAddr(); i++) { fPadMapRCU[i] = new Int_t[6];}
300   
301   //fPadMapHw  = new Float_t[monitor.GetMaxHwAddr()];
302   
303   //fMapEqidsRcu   = new Int_t[1000];
304   //fMapEqidsSec   = new Int_t*[36];
305   for(Int_t i = 0; i<36; i++) { fMapEqidsSec[i]       = new Int_t[6];}
306   SetEqIds();
307   
308   if (gDirectory)
309   {
310     if (!gDirectory->GetList())
311     {
312       Warning("Build","Current directory is not a valid directory");
313       
314     }
315     else
316     {
317       AliTPCMonitor *hold = (AliTPCMonitor*)gDirectory->GetList()->FindObject(monitor.GetName());
318       if(hold)
319       {
320         Warning("Build","Replacing existing histogram: %s (Potential memory leak).",monitor.GetName());
321         gDirectory->GetList()->Remove(hold);
322       }
323       gDirectory->Append(this);
324     }
325   }
326 }
327
328
329 //____________________________________________________________________________
330
331 AliTPCMonitor &AliTPCMonitor:: operator= (const AliTPCMonitor& monitor)
332 {
333   // assigment operator
334   if(this!=&monitor)
335   {
336     ((AliTPCMonitorConfig *)this)->operator=(monitor);
337     fkNRowsIroc=monitor.fkNRowsIroc;
338     fkNRowsOroc=monitor.fkNRowsOroc;
339     fkNPadsIroc=monitor.fkNPadsIroc;
340     fkNPadsOroc=monitor.fkNPadsOroc;
341     fkNPadMinIroc=monitor.fkNPadMinIroc;
342     fkNPadMinOroc=monitor.fkNPadMinOroc;
343     fkNPadMaxIroc=monitor.fkNPadMaxIroc;
344     fkNPadMaxOroc=monitor.fkNPadMaxOroc;
345     fVerb=monitor.fVerb;
346     fLastEv=monitor.fLastEv;
347     fEventNumber=monitor.fEventNumber;
348     fEventNumberOld=monitor.fEventNumberOld;
349     fDisableFit=monitor.fDisableFit;
350     fExecGlob=monitor.fExecGlob;
351     fExecPlaneMax=monitor.fExecPlaneMax;
352     fExecPadIrocRms=monitor.fExecPadIrocRms;
353     fExecPadOrocRms=monitor.fExecPadOrocRms;
354     fRunId=monitor.fRunId;
355     fEqId=monitor.fEqId;
356     fPadUsedRoc=monitor.fPadUsedRoc;
357     fPadUsedHwAddr=monitor.fPadUsedHwAddr;
358     fGdcId=monitor.fGdcId;
359     fLdcId=monitor.fLdcId;
360     fLdcIdOld=monitor.fLdcIdOld;
361     fMapHand=monitor.fMapHand;
362     fRawReader=monitor.fRawReader;
363     
364     
365     fHistList = new TObjArray();
366     fHistIROC=(TH2F*)monitor.fHistIROC->Clone(); fHistList->Add(fHistIROC);
367     fHistOROC=(TH2F*)monitor.fHistOROC->Clone(); fHistList->Add(fHistOROC);
368     fHistIROCIndex=(TH2S*)monitor.fHistIROCIndex->Clone(); fHistList->Add(fHistIROCIndex);
369     fHistOROCIndex=(TH2S*)monitor.fHistOROCIndex->Clone(); fHistList->Add(fHistOROCIndex);
370     fHistIROCTime=(TH2F*)monitor.fHistIROCTime->Clone(); fHistList->Add(fHistIROCTime);
371     fHistOROCTime=(TH2F*)monitor.fHistOROCTime->Clone(); fHistList->Add(fHistOROCTime);
372     fHistIROCClone=(TH2F*)monitor.fHistIROCClone->Clone(); fHistList->Add(fHistIROCClone);
373     fHistOROCClone=(TH2F*)monitor.fHistOROCClone->Clone(); fHistList->Add(fHistOROCClone);
374     fHistIROCRMS=(TH2F*)monitor.fHistIROCRMS->Clone(); fHistList->Add(fHistIROCRMS);
375     fHistOROCRMS=(TH2F*)monitor.fHistOROCRMS->Clone(); fHistList->Add(fHistOROCRMS);
376     fHistIROCBASE=(TH2F*)monitor.fHistIROCBASE->Clone(); fHistList->Add(fHistIROCBASE);
377     fHistOROCBASE=(TH2F*)monitor.fHistOROCBASE->Clone(); fHistList->Add(fHistOROCBASE);
378     fHistIROCSUM=(TH2F*)monitor.fHistIROCSUM->Clone(); fHistList->Add(fHistIROCSUM);
379     fHistOROCSUM=(TH2F*)monitor.fHistOROCSUM->Clone(); fHistList->Add(fHistOROCSUM);
380     
381     fHistChannelTime=(TH2F*)monitor.fHistChannelTime->Clone(); fHistList->Add(fHistChannelTime);
382     
383     fHistAddrMapIndex=(TH1F*)monitor.fHistAddrMapIndex->Clone(); fHistList->Add(fHistAddrMapIndex);
384     fHistAddrMaxAdc=(TH1F*)monitor.fHistAddrMaxAdc->Clone(); fHistList->Add(fHistAddrMaxAdc);
385     fHistAddrBaseMean=(TH1F*)monitor.fHistAddrBaseMean->Clone(); fHistList->Add(fHistAddrBaseMean);
386     fHistAddrMaxAdcX=(TH1F*)monitor.fHistAddrMaxAdcX->Clone(); fHistList->Add(fHistAddrMaxAdcX);
387     fHistAddrAdcSum=(TH1F*)monitor.fHistAddrAdcSum->Clone(); fHistList->Add(fHistAddrAdcSum);
388     fHistAddrBaseRms=(TH1F*)monitor.fHistAddrBaseRms->Clone(); fHistList->Add(fHistAddrBaseRms);
389     
390     
391     fHistDistrSumIROC=(TH1F*)monitor.fHistDistrSumIROC->Clone(); fHistList->Add(fHistDistrSumIROC);
392     fHistDistrMaxIROC=(TH1F*)monitor.fHistDistrMaxIROC->Clone(); fHistList->Add(fHistDistrMaxIROC);
393     fHistDistrSumOROC=(TH1F*)monitor.fHistDistrSumOROC->Clone(); fHistList->Add(fHistDistrSumOROC);
394     fHistDistrMaxOROC=(TH1F*)monitor.fHistDistrMaxOROC->Clone(); fHistList->Add(fHistDistrMaxOROC);
395     
396     fHistDistrBase2dIROC=(TH2F*)monitor.fHistDistrBase2dIROC->Clone(); fHistList->Add(fHistDistrBase2dIROC);
397     fHistDistrBase2dOROC=(TH2F*)monitor.fHistDistrBase2dOROC->Clone(); fHistList->Add(fHistDistrBase2dOROC);
398     fHistDistrBaseRmsIROC=(TH1D*)monitor.fHistDistrBaseRmsIROC->Clone(); fHistList->Add(fHistDistrBaseRmsIROC);
399     fHistDistrBaseMeanIROC=(TH1D*)monitor.fHistDistrBaseMeanIROC->Clone(); fHistList->Add(fHistDistrBaseMeanIROC);
400     fHistDistrBaseRmsOROC=(TH1D*)monitor.fHistDistrBaseRmsOROC->Clone(); fHistList->Add(fHistDistrBaseRmsOROC);
401     fHistDistrBaseMeanOROC=(TH1D*)monitor.fHistDistrBaseMeanOROC->Clone(); fHistList->Add(fHistDistrBaseMeanOROC);
402     
403     fHistGlobalMaxA=(TH2S*)monitor.fHistGlobalMaxA->Clone(); fHistList->Add(fHistGlobalMaxA);
404     fHistGlobalMaxC=(TH2S*)monitor.fHistGlobalMaxC->Clone(); fHistList->Add(fHistGlobalMaxC);
405     
406     fPad       = new Int_t*[monitor.GetMaxHwAddr()];
407     for(Int_t i = 0; i<GetMaxHwAddr(); i++) { fPad[i]       = new Int_t[monitor.GetTimeBins()];}
408     
409     fPadMapRCU = new Int_t*[monitor.GetMaxHwAddr()];
410     for(Int_t i = 0; i<monitor.GetMaxHwAddr(); i++) { fPadMapRCU[i] = new Int_t[6];}
411     
412     fPadMapHw  = new Float_t[monitor.GetMaxHwAddr()];
413     
414     fMapEqidsRcu   = new Int_t[1000];
415     fMapEqidsSec   = new Int_t*[36];
416     for(Int_t i = 0; i<36; i++) { fMapEqidsSec[i]       = new Int_t[6];}
417     SetEqIds();
418     
419     if (gDirectory)
420     {
421       if (!gDirectory->GetList())
422       {
423         Warning("Build","Current directory is not a valid directory");
424         return  *this;
425       }
426       AliTPCMonitor *hold = (AliTPCMonitor*)gDirectory->GetList()->FindObject(monitor.GetName());
427       if(hold)
428       {
429         Warning("Build","Replacing existing histogram: %s (Potential memory leak).",monitor.GetName());
430         gDirectory->GetList()->Remove(hold);
431       }
432       gDirectory->Append(this);
433     }
434   }
435   return *this;
436 }
437
438
439 //____________________________________________________________________________
440 AliTPCMonitor::~AliTPCMonitor() 
441 {
442   // Destructor
443   
444   for(Int_t i = 0; i<GetMaxHwAddr(); i++) { delete[] fPad[i] ;}
445   for(Int_t i = 0; i<GetMaxHwAddr(); i++) { delete[] fPadMapRCU[i];}
446   delete[] fPadMapHw ;
447   DeleteHistos();
448 }
449
450 //____________________________________________________________________________
451 void AliTPCMonitor::CreateHistos() 
452 {
453   // Create histograms to be displayed
454   
455   if(fVerb) cout << " create new ones " << endl;
456   fHistIROC            = new TH2F("fHistIROC"            ,"fHistIROC"           ,fkNRowsIroc,0,fkNRowsIroc,fkNPadsIroc, fkNPadMinIroc, fkNPadMaxIroc);       fHistList->Add(fHistIROC);
457   fHistOROC            = new TH2F("fHistOROC"            ,"fHistOROC"           ,fkNRowsOroc,0,fkNRowsOroc,fkNPadsOroc, fkNPadMinOroc, fkNPadMaxOroc);       fHistList->Add(fHistOROC);
458   
459   fHistIROCIndex       = new TH2S("fHistIROCIndex"       ,"fHistIROCIndex"      ,fkNRowsIroc,0,fkNRowsIroc,fkNPadsIroc, fkNPadMinIroc, fkNPadMaxIroc);       fHistList->Add(fHistIROCIndex);
460   fHistOROCIndex       = new TH2S("fHistOROCIndex"       ,"fHistOROCIndex"      ,fkNRowsOroc,0,fkNRowsOroc,fkNPadsOroc, fkNPadMinOroc, fkNPadMaxOroc);       fHistList->Add(fHistOROCIndex);
461   
462   fHistIROCTime        = new TH2F("fHistIROCTime"        ,"fHistIROCTime"       ,fkNRowsIroc,0,fkNRowsIroc,fkNPadsIroc, fkNPadMinIroc, fkNPadMaxIroc);       fHistList->Add(fHistIROCTime);
463   fHistOROCTime        = new TH2F("fHistOROCTime"        ,"fHistOROCTime"       ,fkNRowsOroc,0,fkNRowsOroc,fkNPadsOroc, fkNPadMinOroc, fkNPadMaxOroc);       fHistList->Add(fHistOROCTime);
464   
465   fHistIROCRMS         = new TH2F("fHistIROCRMS"         ,"fHistIROCRMS"        ,fkNRowsIroc,0,fkNRowsIroc,fkNPadsIroc, fkNPadMinIroc, fkNPadMaxIroc);       fHistList->Add(fHistIROCRMS);
466   fHistOROCRMS         = new TH2F("fHistOROCRMS"         ,"fHistOROCRMS"        ,fkNRowsOroc,0,fkNRowsOroc,fkNPadsOroc, fkNPadMinOroc, fkNPadMaxOroc);       fHistList->Add(fHistOROCRMS);
467   
468   fHistIROCSUM         = new TH2F("fHistIROCSUM"         ,"fHistIROCSUM"        ,fkNRowsIroc,0,fkNRowsIroc,fkNPadsIroc, fkNPadMinIroc, fkNPadMaxIroc);       fHistList->Add(fHistIROCSUM);
469   fHistOROCSUM         = new TH2F("fHistOROCSUM"         ,"fHistOROCSUM"        ,fkNRowsOroc,0,fkNRowsOroc,fkNPadsOroc, fkNPadMinOroc, fkNPadMaxOroc);       fHistList->Add(fHistOROCSUM);
470   
471   fHistIROCBASE        = new TH2F("fHistIROCBASE"        ,"fHistIROCBASE"       ,fkNRowsIroc,0,fkNRowsIroc,fkNPadsIroc, fkNPadMinIroc, fkNPadMaxIroc);       fHistList->Add(fHistIROCBASE);
472   fHistOROCBASE        = new TH2F("fHistOROCBASE"        ,"fHistOROCBASE"       ,fkNRowsOroc,0,fkNRowsOroc,fkNPadsOroc, fkNPadMinOroc, fkNPadMaxOroc);       fHistList->Add(fHistOROCBASE);
473   
474   
475   fHistChannelTime     = new TH2F("fHistChannelTime"     ,"fHistChannelTime"    ,GetNumOfChannels(),0,GetNumOfChannels(),GetTimeBins(),0,GetTimeBins());fHistList->Add(fHistChannelTime);
476   fHistAddrMapIndex    = new TH1F("fHistAddrMapIndex"    ,"fHistAddrMapIndex"   ,GetMaxHwAddr()    ,0,GetMaxHwAddr());                                  fHistList->Add(fHistAddrMapIndex);
477   fHistAddrMaxAdc      = new TH1F("fHistAddrMaxAdc"      ,"fHistAddrMaxAdc"     ,GetMaxHwAddr(),0,GetMaxHwAddr());                                      fHistList->Add(fHistAddrMaxAdc);
478   fHistAddrMaxAdcX     = new TH1F("fHistAddrMaxAdcX"     ,"fHistAddrMaxAdcX"    ,GetMaxHwAddr(),0,GetMaxHwAddr());                                      fHistList->Add(fHistAddrMaxAdcX);
479   fHistAddrBaseMean    = new TH1F("fHistAddrBaseMean"    ,"fHistAddrBaseMean"   ,GetMaxHwAddr(),0,GetMaxHwAddr());                                      fHistList->Add(fHistAddrBaseMean);
480   fHistAddrAdcSum      = new TH1F("fHistAddrAdcSum"      ,"fHistAddrAdcSum"     ,GetMaxHwAddr(),0,GetMaxHwAddr());                                      fHistList->Add(fHistAddrAdcSum);
481   fHistAddrBaseRms     = new TH1F("fHistAddrBaseRms"     ,"fHistAddrBaseRms"    ,GetMaxHwAddr(),0,GetMaxHwAddr());                                      fHistList->Add(fHistAddrBaseRms);
482   fHistDistrSumIROC    = new TH1F("fHistDistrSumIROC"    ,"fHistDistrSumIROC"   ,400,0.0,4000.0);                                                       fHistList->Add(fHistDistrSumIROC);
483   fHistDistrMaxIROC    = new TH1F("fHistDistrMaxIROC"    ,"fHistDistrMaxIROC"   ,500,0.0,1000.0);                                                       fHistList->Add(fHistDistrMaxIROC);
484   fHistDistrSumOROC    = new TH1F("fHistDistrSumOROC"    ,"fHistDistrSumOROC"   ,400,0.0,4000.0);                                                       fHistList->Add(fHistDistrSumOROC);
485   fHistDistrMaxOROC    = new TH1F("fHistDistrMaxOROC"    ,"fHistDistrMaxOROC"   ,500,0.0,1000.0);                                                       fHistList->Add(fHistDistrMaxOROC);
486   
487   fHistDistrBase2dIROC = new TH2F("fHistDistrBase2dIROC" ,"fHistDistrBase2dIROC",100,0.0,100.0,100,0.0,10.0);                                           fHistList->Add(fHistDistrBase2dIROC);
488   fHistDistrBase2dOROC = new TH2F("fHistDistrBase2dOROC" ,"fHistDistrBase2dOROC",100,0.0,100.0,100,0.0,10.0);                                           fHistList->Add(fHistDistrBase2dOROC);
489   
490   fHistGlobalMaxA      = new TH2S("SIDE A"               ,"SIDE A"              ,500,-3000,3000,500,-3000,3000);                                        fHistList->Add(fHistGlobalMaxA);
491   fHistGlobalMaxC      = new TH2S("SIDE C"               ,"SIDE C"              ,500,-3000,3000,500,-3000,3000);                                        fHistList->Add(fHistGlobalMaxC);
492   
493   ResetArrays();
494 }
495 //____________________________________________________________________________
496 Int_t AliTPCMonitor::ProcessEvent()
497 {
498   // Process Event
499   // Depending on the value of the sector id all sectors (sectorid == -1) are processed.
500   //
501   // In this case only the maximum values are calculated per pad and filled to the global histograms
502   // In a second loop the last processed(displayed) sector will be processed (sectorid!=-1)
503   // again and the baseline rms and further quantities are calculated
504   //
505   // If only one sector should be processed SetProcOneSector(1) should be set.
506   // In this case only the specified (last/last displayed) sector will be processed.
507   //
508   // If GetProcNextEvent()==0 the same event will be processed again
509   
510   
511   Int_t sectorid = 0;
512   Int_t retflag  = 0; // id of last sector + 1000,  or error flag
513   if(GetProcNextEvent()==1 && fLastEv) { AliInfo("Last event already processed"); }
514   if(GetProcNextEvent()==1) ResetSectorArray();
515   
516   
517   if(GetProcNextEvent()==0 || GetProcOneSector()==1 ) sectorid = GetLastSector();
518   else                                                sectorid = -1;
519   
520   // first iteration
521   retflag = ReadDataNew(sectorid);
522   
523   SetLastProcFile(GetFile());
524   
525   if(retflag>=10 && retflag<1000){ AliError("Could not read event properly: Check file name and format or try next event");  return 0  ;}
526   
527   DrawHists(3);
528   
529   // second iteration
530   if(sectorid==-1 && retflag >1000)
531   {
532     AliInfo("Second read cycle");
533     SetProcNextEvent(0);
534     if(GetLastSectorDisplayed()==-1) {sectorid =  GetLastSector()         ;    }
535     else                             {sectorid =  GetLastSectorDisplayed();  SetLastSector(sectorid)           ;  }
536     retflag = ReadDataNew(sectorid);
537   }
538   
539   SetLastSectorDisplayed(sectorid)  ;
540   fMapHand->ReadfecHwMap(GetLastSector());
541   FillHistsPadPlane();
542   DrawHists(1);
543   SetEventProcessed(1);
544   return retflag;
545 }
546 //__________________________________________________________________
547 Int_t AliTPCMonitor::ReadDataNew(Int_t secid)
548 {
549   // Read Data File/Stream  for specified Format.
550   // Payload will be extracted from either ROOT or DATE format
551   // and passed to FillHistsDecode for decoding of the adc information
552   
553   if (!fRawReader){
554     fRawReader = AliRawReader::Create(GetFile());
555     SetLastProcFile(GetFile());
556   } else if (TString(GetLastProcFile())!=GetFile()) {
557     delete fRawReader;
558     fRawReader = AliRawReader::Create(GetFile());
559 //     printf("New file!!!\n");
560     SetLastProcFile(GetFile());
561   }
562   
563   if (!fRawReader){
564     AliWarning("Coult not initialize raw reader");
565     return 11;
566   }
567   
568   Bool_t skip=kTRUE;
569   while(skip && GetProcNextEvent())
570   {
571     if(fVerb) cout << "AliTPCMonitor::ReadDataNew get event " << endl;
572     if(fRawReader->IsA()==AliRawReaderRoot::Class()){
573       AliInfo(Form("Root, NextEvent: %d\n",GetEventID()));
574       if (!fRawReader->GotoEvent(GetEventID())){AliError("Could not get next Event"); return 11 ;}
575     } else if(!fRawReader->NextEvent()) { AliError("Could not get next Event"); return 11 ;}
576     // skip all events but physics, calibration and software trigger events!
577     UInt_t eventType=fRawReader->GetType();
578     if ( !(eventType==AliRawEventHeaderBase::kPhysicsEvent ||
579            eventType==AliRawEventHeaderBase::kCalibrationEvent ||
580            eventType==AliRawEventHeaderBase::kSystemSoftwareTriggerEvent ||
581            eventType==AliRawEventHeaderBase::kDetectorSoftwareTriggerEvent) ) {
582              if (fVerb) cout<< "Skipping event! Its neither of 'physics, calibration and software trigger event'" << endl;
583              if(fRawReader->IsA()==AliRawReaderRoot::Class()){
584                if (fEventNumber<fRawReader->GetNumberOfEvents()-1) ++fEventNumber;
585                else {AliError("No more events");return 11;}
586              }
587              continue;
588            }
589     skip=kFALSE;
590     //test if the TPC has data
591     UChar_t *data=0;
592     fRawReader->Select("TPC");
593     Int_t eventNr=fRawReader->GetEventIndex();
594     if (!fRawReader->ReadNextData(data)) {
595       skip=kTRUE;
596       AliInfo(Form("%d / %d",fEventNumber,fRawReader->GetNumberOfEvents()));
597       if(fRawReader->IsA()==AliRawReaderRoot::Class()){
598         if (fEventNumber<fRawReader->GetNumberOfEvents()-1){
599           ++eventNr;
600 //           printf("inc conter\n");
601         }
602         else {
603           AliError("No more events");
604           return 11;
605         }
606       }
607     }
608     fEventNumber = eventNr;
609     fEventNumberOld = eventNr;
610   }
611   
612   AliInfo(Form("secid: %d",secid));
613   
614   //========================== Histogram filling ======================
615   ResetHistos() ;
616   AliAltroRawStreamV3 *altro=new AliAltroRawStreamV3(fRawReader);
617   altro->SelectRawData("TPC");
618   altro->Reset();
619   fChannelIter=0;
620   
621   Int_t     hw                = 0;
622   Int_t     nextHwAddress     = 0;
623   Int_t     rcupatch          = 0;
624   Int_t     maxADC            = 0;
625   Int_t     maxx              = 0;
626   Int_t     sum               = 0;
627   Int_t     sumn              = 0;
628   Int_t           lastrcuid   = 0;
629   
630   while ( altro->NextDDL() ){
631     fGdcId        = fRawReader->GetGDCId() ;
632     fLdcId        = fRawReader->GetLDCId() ;
633     fRunId        = fRawReader->GetRunNumber() ;
634     fEqId         = fRawReader->GetEquipmentId();
635     rcupatch      = GetRCUPatch(fRunId, fEqId);
636     Int_t rcupatchSector=rcupatch%6;
637     lastrcuid     = (rcupatch+1000);
638
639     Int_t currentSector=rcupatch/6;
640     
641     if(fLdcIdOld!=fLdcId &&  fChannelIter!=0) {
642       if(secid==-1)
643       {
644         FillGlobal(GetLastSector());
645         ResetArrays();
646         if (fVerb) printf("filled sector: %d\n",GetLastSector());
647         fChannelIter =0;
648       }
649 //       else
650 //       {
651 //         printf("RET: filled sector: %d\n",GetLastSector());
652 //         return lastrcuid;
653 //         if (rcupatch/6!=secid) continue;
654 //       }
655 //       fChannelIter=0;
656     }
657     
658     if (!CheckEqId(secid,fEqId)) continue;
659     if (fVerb) printf("Sector: %d, RCU patch: %d, LDC: %d, EqId: %d\n",currentSector,rcupatch, fLdcId, fEqId);
660     
661     while ( altro->NextChannel() ){
662       hw=altro->GetHWAddress();
663       nextHwAddress         = ( hw + (rcupatchSector<<12) );
664       fPad[fChannelIter][0] = nextHwAddress ;
665       fPadMapHw[nextHwAddress]    =  fChannelIter  ;
666       maxADC=0;
667       while ( altro->NextBunch() ){
668         Int_t  startTbin    = (Int_t)altro->GetStartTimeBin();
669         Int_t  bunchlength  = (Int_t)altro->GetBunchLength();
670         const UShort_t *sig = altro->GetSignals();
671         for (Int_t iTimeBin = 0; iTimeBin<bunchlength; iTimeBin++){
672           Int_t adc=(Int_t)sig[iTimeBin];
673           Int_t ntime=startTbin-iTimeBin;
674           //fill channel information
675           fPad[fChannelIter][ntime]  = adc;
676           if( (adc>maxADC) && (ntime>=GetRangeMaxAdcMin()) && (ntime<GetRangeMaxAdcMax()  ))  {maxADC = adc;maxx = ntime ;}
677           if(              (ntime>=GetRangeSumMin())    && (ntime<GetRangeSumMax()     ))  {sum+=adc; sumn++;}
678           
679         }
680       }
681       //get pedestal, noise
682       Float_t pedestal=TMath::Mean(GetRangeBaseMax()-GetRangeBaseMin(),fPad[fChannelIter]+GetRangeBaseMin());
683       Float_t noise   =TMath::RMS(GetRangeBaseMax()-GetRangeBaseMin(),fPad[fChannelIter]+GetRangeBaseMin());
684       fHistAddrMaxAdc->SetBinContent(nextHwAddress,maxADC-GetPedestals()*pedestal);
685       
686       if(secid!=-1)
687       {
688         if(rcupatchSector<2)
689         {
690           fHistDistrBase2dIROC->Fill(pedestal,noise);
691           fHistDistrSumIROC->Fill(sum);
692           fHistDistrMaxIROC->Fill(maxADC-pedestal*GetPedestals());
693           fHistDistrSumIROC->Fill(sum -sumn*pedestal*GetPedestals());
694         }
695         else
696         {
697           fHistDistrBase2dOROC->Fill(pedestal,noise);
698           fHistDistrSumOROC->Fill(sum);
699           fHistDistrMaxOROC->Fill(maxADC-pedestal*GetPedestals());
700           fHistDistrSumOROC->Fill(sum -sumn*pedestal*GetPedestals());
701         }
702         
703         fHistAddrAdcSum->SetBinContent(  nextHwAddress,sum);
704         fHistAddrMapIndex->SetBinContent(nextHwAddress,fChannelIter);
705         fHistAddrBaseMean->SetBinContent(nextHwAddress,pedestal);
706         fHistAddrMaxAdcX->SetBinContent( nextHwAddress,maxx);
707         fHistAddrBaseRms->SetBinContent( nextHwAddress,noise);
708       }
709       
710       ++fChannelIter;
711     }
712     SetLastSector(rcupatch/6);
713     if(fChannelIter!=0 && secid==-1 ) SetSectorFilled(rcupatch/6);
714     fLdcIdOld = fLdcId ;
715   }
716   delete altro;
717   if(fChannelIter!=0 && secid==-1) { FillGlobal(GetLastSector());}
718   return lastrcuid;
719 }
720
721
722
723
724
725
726
727
728
729
730
731 //____________________________________________________________________________
732 void AliTPCMonitor::FillHistsPadPlane() 
733 {
734   // Fill 2Dim histograms for IROC and OROC (max , rms and sum)
735   
736   if(fVerb)cout << "AliTPCMonitor::FillHistsPadPlane() Start  " << endl;
737   if(fVerb)PrintConfig();
738   
739   Int_t pad    = 0;
740   Int_t row    = 0;
741   Int_t padmax = 0;
742   Int_t hwadd  = 0;
743   
744   for(Int_t ch = 0; ch<fChannelIter; ch++)
745   {
746     hwadd=  fPad[ch][0];
747     fHistChannelTime->SetCellContent(ch,0,hwadd);
748     
749     for(Int_t bin = 1; bin <GetTimeBins(); bin++)
750     {
751       if( fHistChannelTime->GetCellContent(ch,bin)!=0)  cout << " cellcontent already set " << endl;
752       if(     GetPedestals()==1 ) fHistChannelTime->SetCellContent(ch,bin,(fPad[ch][bin]- fHistAddrBaseMean->GetBinContent(hwadd)));
753       else                        fHistChannelTime->SetCellContent(ch,bin,(fPad[ch][bin]));
754     }
755     
756     pad    = fMapHand->GetPad(   hwadd);
757     row    = fMapHand->GetPadRow(hwadd);
758     padmax = fMapHand->GetNumofPads(row);
759     
760     if(row<63)
761     {
762       fHistIROC->SetCellContent(     row    +1 ,pad +55 -padmax/2 +1,fHistAddrMaxAdc->GetBinContent(  hwadd));
763       fHistIROCIndex->SetCellContent(row    +1 ,pad +55 -padmax/2 +1,ch);
764       fHistIROCRMS->SetCellContent(  row    +1 ,pad +55 -padmax/2 +1,fHistAddrBaseRms->GetBinContent( hwadd));
765       fHistIROCBASE->SetCellContent( row    +1 ,pad +55 -padmax/2 +1,fHistAddrBaseMean->GetBinContent(hwadd));
766       fHistIROCSUM->SetCellContent(  row    +1 ,pad +55 -padmax/2 +1,fHistAddrAdcSum->GetBinContent(  hwadd));
767     }
768     else
769     {
770       fHistOROC->SetCellContent(     row-63 +1 ,pad +70 -padmax/2 +1,fHistAddrMaxAdc->GetBinContent(  hwadd));
771       fHistOROCIndex->SetCellContent(row-63 +1 ,pad +70 -padmax/2 +1,ch);
772       fHistOROCRMS->SetCellContent(  row-63 +1 ,pad +70 -padmax/2 +1,fHistAddrBaseRms->GetBinContent( hwadd));
773       fHistOROCBASE->SetCellContent( row-63 +1 ,pad +70 -padmax/2 +1,fHistAddrBaseMean->GetBinContent(hwadd));
774       fHistOROCSUM->SetCellContent(  row-63 +1 ,pad +70 -padmax/2 +1,fHistAddrAdcSum->GetBinContent(  hwadd));
775     }
776   }
777   
778   fHistChannelTime->GetXaxis()->SetRange(0,fChannelIter);
779   fHistChannelTime->GetYaxis()->SetRange(0,GetTimeBins());
780 }
781
782
783
784 //____________________________________________________________________________
785 void AliTPCMonitor::ResetArrays() 
786 {
787   // Reset data arrays
788   for(Int_t row = 0 ; row < fkNRowsIroc; row++)
789   {
790     for(Int_t pad = 0 ; pad <  fkNPadsIroc ; pad++)
791     {
792       fHistIROCIndex->SetCellContent(row+1,pad+1,-1);
793     }
794   }
795   for(Int_t row = 0 ; row < fkNRowsOroc; row++)
796   {
797     for(Int_t pad = 0 ; pad <  fkNPadsOroc ; pad++)
798     {
799       fHistOROCIndex->SetCellContent(row+1,pad+1,-1);
800     }
801   }
802   
803   for(Int_t ch= 0; ch<GetMaxHwAddr(); ch++)
804   {
805     fHistAddrMaxAdcX->SetBinContent(ch,-1);
806     fHistAddrMapIndex->SetBinContent(ch,-1);
807     fHistAddrMaxAdc->SetBinContent(  ch, 0);
808     fHistAddrBaseMean->SetBinContent(  ch, 0);
809     fHistAddrAdcSum->SetBinContent(  ch, 0);
810     fHistAddrBaseRms->SetBinContent(ch, 0);
811   }
812   
813   for(Int_t ch = 0; ch< GetNumOfChannels(); ch++)
814   {
815     for(Int_t bin = 0; bin< GetTimeBins(); bin++)
816     {
817       fPad[ch][bin] = 0;
818     }
819   }
820   for(Int_t ch = 0; ch< GetMaxHwAddr(); ch++)
821   {
822     fPadMapHw[ch]=-1;
823     fPadMapRCU[ch][0]=-1;
824     fPadMapRCU[ch][1]=-1;
825     fPadMapRCU[ch][2]=-1;
826     fPadMapRCU[ch][3]=-1;
827     fPadMapRCU[ch][4]=-1;
828     fPadMapRCU[ch][5]=-1;
829   }
830   fPadUsedHwAddr=-1;
831 }
832
833
834 //____________________________________________________________________________
835 void AliTPCMonitor::ResetHistos() 
836 {
837   // Reset all but
838   for(Int_t i =0; i<fHistList->GetEntries(); i++)
839   {
840     TString name=fHistList->At(i)->GetName();
841     if(GetProcNextEvent()==0 && (name=="SIDE A" || name=="SIDE C")) continue;
842     ((TH1*)fHistList->At(i))->Reset();
843   }
844   ResetArrays();
845 }
846
847 //____________________________________________________________________________
848 void AliTPCMonitor::DeleteHistos() 
849 {
850   // Delete histograms
851   for(Int_t i =0; i<fHistList->GetEntries(); i++)
852   {
853     delete (TH1*)fHistList->At(i);
854   }
855 }
856
857
858 //__________________________________________________________________
859 Int_t AliTPCMonitor::CheckEqId(Int_t secid,Int_t eqid)
860 {
861   // Check if equipment id corresponds to any  rcu patch in sector
862   // Equipment ids changed during commisioning in 2006 (starting from run 704)
863   // However Runids started from 0 again in 2007
864   // Now only runids from commissioning in 2006 after runid 704 and all new ones are supported.
865   // Comment in equipment check for runids < 704 if old runs should be processed
866   
867   if(fVerb) cout << "AliTPCMonitor::CheckEqId  : SectorId  " << secid << " EquipmentId " << eqid  << " runid " << fRunId <<  endl;
868   Int_t passed =1;
869   //skip all eqids which do not belong to the TPC
870   if ( eqid<768||eqid>983 ) return 0;
871   //
872 //   if(fRunId<704 && 0) // commented out --> runs with runid < 704 in 2006 are not recognized anymore
873 //   {
874 //     if( (secid>-1) && (secid<36) )   // if ( secid is in range) { take only specific eqids}  else { take all }
875 //     {
876 //       if(      (secid==13) && ( eqid!=408 && eqid!=409  &&  eqid!=509 && eqid!=512  && eqid!=513 && eqid!=517 )) {passed=0;}
877 //       else if( (secid==4)  && ( eqid!=404 && eqid!=504  &&  eqid!=407 && eqid!=503  && eqid!=508 && eqid!=506 )) {passed=0;}
878 //     }
879 //     else                                                                   {if(fVerb) cout << "passed check "<< endl; }
880 //   }
881 //   else
882 //   {
883     if( (secid>-1) && (secid<36) )   // if ( secid is in range) { take only specific eqids}  else { take all }
884     {
885       if(eqid!=fMapEqidsSec[secid][0] && eqid!= fMapEqidsSec[secid][1] && eqid!=fMapEqidsSec[secid][2] &&
886          eqid!=fMapEqidsSec[secid][3] && eqid!= fMapEqidsSec[secid][4] && eqid!=fMapEqidsSec[secid][5] )  {passed=0;}
887     }
888     else                                                                   {if(fVerb) cout << "passed check "<< endl;}
889 //   }
890   
891   return passed;
892 }
893
894 //__________________________________________________________________
895 void AliTPCMonitor::SetEqIds()
896 {
897   // Set mapping for equipment ids
898   for(Int_t i = 0; i<36 ; i++)
899   {
900     for(Int_t j = 0; j<6; j++)
901     {
902       if(j<2) fMapEqidsSec[i][j]= 768+i*2+j;
903       else    fMapEqidsSec[i][j]= 840+i*4+j-2;
904     }
905   }
906   
907   for(Int_t i = 0; i<36 ; i++)
908   {
909     for(Int_t j = 0; j<6; j++)
910     {
911       if(j<2) fMapEqidsRcu[768+i*2+j]   = i*6 +j;
912       else    fMapEqidsRcu[840+i*4+j-2] = i*6 +j;
913     }
914   }
915 }
916
917 //__________________________________________________________________
918 void AliTPCMonitor::FillGlobal(Int_t sector) 
919 {
920   
921   // Fill global histograms with max adc for each channel
922   
923   TH2S* hglob =0;
924   if((sector/18) ==0) hglob =  fHistGlobalMaxA;
925   else                hglob =  fHistGlobalMaxC;
926   
927   Float_t  rotsec  = (2*TMath::Pi()/18.0);
928   Float_t  rot     = (-rotsec*(sector%18)  +4*rotsec);
929   
930   Float_t  m11     =    TMath::Cos(rot);
931   Float_t  m12     =    TMath::Sin(rot);
932   Float_t  m21     = -1*TMath::Sin(rot);
933   Float_t  m22     =    TMath::Cos(rot);
934   
935   Int_t    max     = 0; // use integer for global view
936   
937   Double_t xval    = 0.0;
938   Double_t yval    = 0.0;
939   
940   Int_t    pad     = 0;
941   Int_t    row     = 0;
942   Int_t    padmax  = 0;
943   
944   Float_t  xdr     = 0;
945   Float_t  ydr     = 0;
946   
947   for(Int_t hw = 0; hw<fHistAddrMaxAdc->GetNbinsX(); hw++)
948   {
949     max = (Int_t)fHistAddrMaxAdc->GetBinContent(hw);
950     if(max!=-1)
951     {
952       pad    = fMapHand->GetPad(   hw);
953       row    = fMapHand->GetPadRow(hw);
954       if (row==-1) continue;
955       padmax = fMapHand->GetNumofPads(row);
956       if (sector%36>17) fMirror=-1;
957       else fMirror=1;
958       GetXY(xval ,yval , padmax,row ,pad);
959       xdr    =  xval*m11 +yval*m12;
960       ydr    =  xval*m21 +yval*m22;
961       if(hglob->GetBinContent(hglob->GetXaxis()->FindBin(xdr),hglob->GetYaxis()->FindBin(ydr))==0)   hglob->Fill(xdr,ydr,(Int_t)max);
962     }
963   }
964 }
965
966
967 //__________________________________________________________________
968 void AliTPCMonitor::GetXY( Double_t& xval , Double_t& yval , Int_t padmax, Int_t row , Int_t pad) const 
969 {
970   // Get x and y position of pad
971   
972   if(row<63)
973   {
974     xval = fMirror*( 2*padmax -4*pad -2);
975     yval = 852.25 +7.5*row;
976   }
977   else
978   {
979     xval = fMirror*( 3*padmax -6*pad -3);
980     if((row-63)<63) {     yval = 10*(row-63) +1351;     }
981     else              {   yval = 15*(row-63-64)+1993.5; }
982   }
983   
984
985
986 //__________________________________________________________________
987 Int_t AliTPCMonitor::GetPadAtX(Float_t xval, Int_t row, Int_t padmax) const
988 {
989   // Get pad number at given position in x
990   Int_t pad    = 0;
991   
992   if(row<63) {pad = (Int_t)( ( (xval/fMirror) +2 -2*padmax)/-4);}
993   else       {pad = (Int_t)( ( (xval/fMirror) +3 -3*padmax)/-6);}
994   
995   if(pad>=padmax) return -1;
996   else            return pad ;
997   
998 }
999
1000 //__________________________________________________________________
1001 Int_t AliTPCMonitor::GetPadAtX(Float_t xval, Int_t row) const
1002 {
1003   
1004  // Get pad number at given position in x
1005   
1006   Int_t padmax = fMapHand->GetNumofPads(row);
1007   Int_t pad    = 0;
1008   
1009   if(row<63) {pad = (Int_t)( ( (xval/fMirror) +2 -2*padmax)/-4);}
1010   else       {pad = (Int_t)( ( (xval/fMirror) +3 -3*padmax)/-6);}
1011   
1012   if(pad>=padmax) return -1;
1013   else            return pad ;
1014   
1015 }
1016
1017 //__________________________________________________________________
1018 void AliTPCMonitor::DrawHists(Int_t histos) 
1019 {
1020   
1021   // Draw sets of histograms
1022   // histos==1 : 2Dim histos for MAX adc  and add executables
1023   // histos==2 : distributions max/rms/sum
1024   // histos==3 : global max adc for specified SideA/C
1025   
1026   
1027   if(fVerb)    cout << " Draw histos " << endl;
1028   TString cside;
1029   if(GetLastSector()/18==0 ) cside="A";
1030   else                       cside="C";
1031   
1032   TString titleSEC  = Form("Sector %i Side %s Run : %05i EventID %i "       ,GetLastSector()%18,cside.Data(),fRunId, fEventNumber);
1033   TString titleEvent= Form("Time <-> Channles  %s"                          ,titleSEC.Data());
1034   TString titleIROC = Form("IROC %s"                                        ,titleSEC.Data());
1035   TString titleOROC = Form("OROC %s"                                        ,titleSEC.Data());
1036   
1037   TString titleMAX  = Form("Max (timebin: %i,%i) %s"                        ,GetRangeMaxAdcMin(),GetRangeMaxAdcMax(),titleSEC.Data());
1038   TString titleSUM  = Form("Sum (timebin: %i,%i) %s"                        ,GetRangeSumMin()   ,GetRangeSumMax()   ,titleSEC.Data());
1039   TString titleBASE = Form("Baseline RMS<->Mean  (timebin: %i-%i) %s"       ,GetRangeBaseMin()  ,GetRangeBaseMax()  ,titleSEC.Data());
1040   TString titleMEAN = Form("Baseline Mean (timebin: %i-%i) %s"              ,GetRangeBaseMin()  ,GetRangeBaseMax()  ,titleSEC.Data());
1041   TString titleRMS  = Form("Baseline RMS (timebin: %i-%i) %s"               ,GetRangeBaseMin()  ,GetRangeBaseMax()  ,titleSEC.Data());
1042   
1043   if(histos==1)
1044   {
1045       // IROC _______________________________________________________________
1046     TCanvas* ciroc = 0;
1047     ciroc = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("ciroc");
1048     if(!ciroc)
1049     {
1050       ciroc = CreateCanvas("ciroc");
1051       fExecPlaneMax=0;
1052     }
1053     ciroc->cd();
1054     
1055     fHistIROC->SetXTitle("row");
1056     fHistIROC->SetYTitle("pad");
1057     if(GetPedestals()) fHistIROC->SetZTitle("max ADC (baseline sub)");
1058     else               fHistIROC->SetZTitle("max ADC ");
1059     fHistIROC->SetTitle(titleIROC.Data());
1060     fHistIROC->SetMinimum(0.01);
1061     fHistIROC->Draw("COLZ");
1062     ciroc->UseCurrentStyle();
1063     
1064     
1065     fHistIROCTime->SetXTitle("row"); fHistIROCTime->SetZTitle("peak time (fit)");       fHistIROCTime->SetYTitle("pad");      fHistIROCTime->SetTitle(titleIROC.Data());
1066     fHistIROCRMS->SetXTitle("row");  fHistIROCRMS->SetZTitle( "baseline rms (ADC)");    fHistIROCRMS->SetYTitle("pad");       fHistIROCRMS->SetTitle(titleIROC.Data());
1067     
1068       // OROC
1069     TCanvas* coroc = 0;
1070     coroc =(TCanvas*)gROOT->GetListOfCanvases()->FindObject("coroc");
1071     if(!coroc) {
1072       coroc = CreateCanvas("coroc");
1073       fExecPlaneMax=0;
1074     }
1075     coroc->cd();
1076     
1077     fHistOROC->SetXTitle("row");
1078     fHistOROC->SetYTitle("pad");
1079     if(GetPedestals()) fHistOROC->SetZTitle("max ADC (baseline sub)");
1080     else               fHistOROC->SetZTitle("max ADC ");
1081     fHistOROC->SetTitle(titleOROC.Data());
1082     fHistOROC->SetMinimum(0.01);
1083     fHistOROC->Draw("COLZ");
1084     coroc->UseCurrentStyle();
1085     
1086     
1087     fHistOROCTime->SetXTitle("row"); fHistOROCTime->SetZTitle("peak time (fit) (timebins)"); fHistOROCTime->SetYTitle("pad"); fHistOROCTime->SetTitle(titleOROC.Data());
1088     fHistOROCRMS->SetXTitle("row");  fHistOROCRMS->SetZTitle("baseline rms (ADC)");          fHistOROCRMS->SetYTitle("pad");  fHistOROCRMS->SetTitle(titleOROC.Data());
1089     
1090     // SUM
1091     TString namesum=Form("ADC sum (bins: %i, %i)",GetRangeSumMin() ,GetRangeSumMax() );
1092     fHistIROCSUM->SetXTitle("row");
1093     fHistIROCSUM->SetZTitle(namesum.Data());
1094     fHistIROCSUM->SetYTitle("pad");
1095     fHistIROCSUM->SetTitle(titleIROC.Data());
1096     
1097     fHistOROCSUM->SetXTitle("row");
1098     fHistOROCSUM->SetZTitle(namesum);
1099     fHistOROCSUM->SetYTitle("pad");
1100     fHistOROCSUM->SetTitle(titleOROC.Data());
1101     
1102     // BASE
1103     TString namebase=Form("base mean (timbebin: %i, %i )",GetRangeBaseMin(),GetRangeBaseMax());
1104     fHistIROCBASE->SetXTitle("row");
1105     fHistIROCBASE->SetZTitle(namebase.Data());
1106     fHistIROCBASE->SetYTitle("pad");
1107     fHistIROCBASE->SetTitle(titleIROC.Data());
1108     
1109     fHistOROCBASE->SetXTitle("row");
1110     fHistOROCBASE->SetZTitle(namebase);
1111     fHistOROCBASE->SetYTitle("pad");
1112     fHistOROCBASE->SetTitle(titleOROC.Data());
1113     
1114     if(fHistIROCClone) fHistIROCClone->Delete();
1115     if(fHistOROCClone) fHistOROCClone->Delete();
1116     fHistIROCClone = (TH2F*)fHistIROC->Clone("fHistIROCClone");
1117     fHistOROCClone = (TH2F*)fHistOROC->Clone("fHistOROCClone");
1118     
1119       // Executables
1120     if(fExecPlaneMax==0)
1121     {
1122       TString carry1=Form(".x %s/TPC/AliTPCMonitorExec.C(1)",gSystem->Getenv("ALICE_ROOT"));
1123       ciroc->AddExec("pad",carry1.Data());
1124       coroc->AddExec("pad",carry1.Data());
1125       
1126       TString carry2=Form(".x %s/TPC/AliTPCMonitorExec.C(2)",gSystem->Getenv("ALICE_ROOT"));
1127       ciroc->AddExec("row",carry2.Data());
1128       coroc->AddExec("row",carry2.Data());
1129       fExecPlaneMax=1;
1130     }
1131     coroc->Update();
1132     ciroc->Update();
1133   }
1134   else if(histos==2)
1135   {
1136       // MAX ADC distribution  ____________________________________________
1137     TCanvas* cmax = 0;
1138     cmax = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("cmax");
1139     if(!cmax)  cmax = CreateCanvas("cmax");
1140     
1141     cmax->cd();
1142     fHistDistrMaxIROC->GetXaxis()->SetRangeUser(0.0,1000.0);
1143     fHistDistrMaxIROC->SetXTitle("max ADC (ADC)");
1144     fHistDistrMaxIROC->SetYTitle("counts");
1145     fHistDistrMaxIROC->SetTitle(titleMAX.Data());
1146     fHistDistrMaxIROC->Draw("");
1147     fHistDistrMaxOROC->SetLineColor(2);
1148     fHistDistrMaxOROC->Draw("same");
1149     
1150     if(fHistDistrMaxOROC->GetMaximum()> fHistDistrMaxIROC->GetMaximum())  fHistDistrMaxIROC->SetMaximum(fHistDistrMaxOROC->GetMaximum()*1.1);
1151     
1152     TLegend* legio = new TLegend(0.6,0.6,0.8,0.8);
1153     legio->SetFillColor(0);
1154     legio->AddEntry(fHistDistrMaxIROC,"IROC","l");
1155     legio->AddEntry(fHistDistrMaxOROC,"OROC","l");
1156     legio->Draw("same");
1157     
1158       // ADC sum distribution
1159     TCanvas* csum = 0;
1160     csum = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("csum");
1161     if(!csum)  csum = CreateCanvas("csum") ;
1162     csum->cd();
1163     
1164     fHistDistrSumIROC->SetXTitle("sum ADC (ADC)");
1165     fHistDistrSumIROC->SetYTitle("counts");
1166     fHistDistrSumIROC->SetTitle(titleSUM.Data());
1167     fHistDistrSumIROC->Draw("");
1168     fHistDistrSumOROC->SetLineColor(2);
1169     fHistDistrSumOROC->Draw("same");
1170     if(fHistDistrSumOROC->GetMaximum()> fHistDistrSumIROC->GetMaximum())  fHistDistrSumIROC->SetMaximum(fHistDistrSumOROC->GetMaximum()*1.1);
1171     legio->Draw("same");
1172     
1173       // BASELINE MEAN distribution
1174     TCanvas* cbasemean = 0;
1175     cbasemean = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("cbasemean");
1176     if(!cbasemean)  cbasemean = CreateCanvas("cbasemean");
1177     cbasemean->cd();
1178     
1179     fHistDistrBaseMeanIROC = fHistDistrBase2dIROC->ProjectionX("fHistDistrBaseMeanIROC");
1180     fHistDistrBaseMeanIROC->SetXTitle("base mean (ADC)");
1181     fHistDistrBaseMeanIROC->SetYTitle("counts");
1182     fHistDistrBaseMeanIROC->SetTitle(titleMEAN.Data());
1183     fHistDistrBaseMeanIROC->Draw("");
1184     
1185     fHistDistrBaseMeanOROC = fHistDistrBase2dOROC->ProjectionX("fHistDistrBaseMeanOROC");
1186     fHistDistrBaseMeanOROC->SetLineColor(2);
1187     fHistDistrBaseMeanOROC->Draw("same");
1188     if(fHistDistrBaseMeanOROC->GetMaximum()>fHistDistrBaseMeanIROC->GetMaximum())   fHistDistrBaseMeanIROC->SetMaximum(fHistDistrBaseMeanOROC->GetMaximum()*1.1);
1189     legio->Draw("same");
1190     
1191     TCanvas* cbaserms = 0;
1192     cbaserms = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("cbaserms");
1193     if(!cbaserms) cbaserms = CreateCanvas("cbaserms") ;
1194     cbaserms->cd();
1195     
1196       // BASELINE RMS distribution
1197     fHistDistrBaseRmsIROC = fHistDistrBase2dIROC->ProjectionY("fHistDistrBaseRmsIROC");
1198     fHistDistrBaseRmsIROC->SetXTitle("base rms (ADC)");
1199     fHistDistrBaseRmsIROC->SetYTitle("counts");
1200     fHistDistrBaseRmsIROC->SetTitle(titleRMS.Data());
1201     fHistDistrBaseRmsIROC->Draw("");
1202     
1203     fHistDistrBaseRmsOROC = fHistDistrBase2dOROC->ProjectionY("fHistDistrBaseRmsOROC");
1204     fHistDistrBaseRmsOROC->SetLineColor(2);
1205     fHistDistrBaseRmsOROC->Draw("same");
1206     if(fHistDistrBaseRmsOROC->GetMaximum()>fHistDistrBaseRmsIROC->GetMaximum())  fHistDistrBaseRmsIROC->SetMaximum(fHistDistrBaseRmsOROC->GetMaximum()*1.1);
1207     legio->Draw("same");
1208     
1209     cmax->Update();
1210     csum->Update();
1211     cbasemean->Update();
1212     cbaserms->Update();
1213   }
1214   else  if(histos==3)
1215   {
1216       // GLOBAL MAX ADC _________________________________
1217     if(GetProcNextEvent()==1)
1218     {
1219       TCanvas* cglobA =0;
1220       TCanvas* cglobC =0;
1221       
1222       if(!(cglobC=(TCanvas*)gROOT->GetListOfCanvases()->FindObject("SIDE C all"))) cglobC = CreateCanvas("SIDE C all");
1223       if(!(cglobA=(TCanvas*)gROOT->GetListOfCanvases()->FindObject("SIDE A all"))) cglobA = CreateCanvas("SIDE A all");
1224       
1225       TString globtitle1=Form("SIDE A Run %05i (EventID %i)",fRunId,fEventNumber);
1226       TString globtitle2=Form("SIDE C Run %05i (EventID %i)",fRunId,fEventNumber);
1227       
1228       fHistGlobalMaxA->SetTitle(globtitle1.Data());
1229       fHistGlobalMaxC->SetTitle(globtitle2.Data());
1230       fHistGlobalMaxA->SetXTitle("x/mm");
1231       fHistGlobalMaxA->SetYTitle("y/mm");
1232       fHistGlobalMaxC->SetXTitle("x/mm");
1233       fHistGlobalMaxC->SetYTitle("y/mm");
1234       
1235       if(GetPedestals()==0)     {             fHistGlobalMaxA->SetZTitle("max adc (not baseline sub)");   fHistGlobalMaxC->SetZTitle("max adc (not baseline sub)");  }
1236       else                          {         fHistGlobalMaxA->SetZTitle("max adc ");                     fHistGlobalMaxC->SetZTitle("max adc ");                          }
1237       
1238       fHistGlobalMaxA->SetMinimum(0.01);
1239       fHistGlobalMaxC->SetMinimum(0.01);
1240       
1241       cglobC->cd() ; fHistGlobalMaxC->Draw("COLZ");
1242       cglobA->cd() ; fHistGlobalMaxA->Draw("COLZ");
1243       
1244       TString nameom=Form(".x  %s/TPC/AliTPCMonitorExec.C(3)",gSystem->Getenv("ALICE_ROOT"));
1245       
1246       if(fExecGlob==0)
1247       {
1248         if(fVerb)cout << " set exec " << nameom.Data() << endl;
1249         cglobC->AddExec("glob",nameom.Data());
1250         cglobA->AddExec("glob",nameom.Data());
1251         fExecGlob = 1;
1252       }
1253       else
1254       {
1255         cglobC->DeleteExec("glob");
1256         cglobA->DeleteExec("glob");
1257         
1258         if(fVerb)  cout << " set exec " << nameom.Data() << endl;
1259         cglobC->AddExec("glob",nameom.Data());
1260         cglobA->AddExec("glob",nameom.Data());
1261         
1262       }
1263       cglobC->Update();
1264       cglobA->Update();
1265     }
1266     
1267   }
1268 }
1269
1270
1271
1272 //__________________________________________________________________
1273 void AliTPCMonitor::DrawRMSMap() 
1274 {
1275   // Draw 2Dim rms histos for IROC and OROC
1276   // and set executables for canvases
1277   
1278   TCanvas* crmsoroc =0;
1279   TCanvas* crmsiroc =0;
1280   if(!(crmsoroc = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("crmsoroc")))    crmsoroc    = CreateCanvas("crmsoroc");
1281   if(!(crmsiroc = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("crmsiroc")))    crmsiroc    = CreateCanvas("crmsiroc");
1282   
1283   crmsiroc->cd();  fHistIROCRMS->Draw("COLZ");
1284   crmsoroc->cd();  fHistOROCRMS->Draw("COLZ");
1285   
1286   TString carry1=Form(".x %s/TPC/AliTPCMonitorExec.C(1)",gSystem->Getenv("ALICE_ROOT"));
1287   TString carry2=Form(".x %s/TPC/AliTPCMonitorExec.C(2)",gSystem->Getenv("ALICE_ROOT"));
1288   
1289   if(fExecPadIrocRms==0)
1290   {
1291     crmsiroc->AddExec("pad",carry1.Data());
1292     crmsiroc->AddExec("row",carry2.Data());
1293     fExecPadIrocRms=1;
1294   }
1295   
1296   if(fExecPadOrocRms==0)
1297   {
1298     crmsoroc->AddExec("pad",carry1.Data());
1299     crmsoroc->AddExec("row",carry2.Data());
1300     fExecPadOrocRms=1;
1301   }
1302   
1303   crmsiroc->Update();
1304   crmsoroc->Update();
1305   
1306   DrawHists(2);
1307   
1308 }
1309
1310 //__________________________________________________________________
1311 void AliTPCMonitor::ExecPad() 
1312 {
1313   
1314   // Executable for Pad
1315   // Show time profile for channel the mouse is pointing at
1316   
1317   Int_t event = gPad->GetEvent();
1318   if (event != 51)   return;
1319   
1320   TObject *select = gPad->GetSelected();
1321   if(!select)    return;
1322   if(!select->InheritsFrom("TH2")) { return;  }
1323   gPad->GetCanvas()->FeedbackMode(kTRUE);
1324   
1325   // get position
1326   Int_t    px        = gPad->GetEventX();
1327   Int_t    py        = gPad->GetEventY();
1328   Float_t  upy       = gPad->AbsPixeltoY(py);
1329   Float_t  upx       = gPad->AbsPixeltoX(px);
1330   Float_t  y         = gPad->PadtoY(upy);
1331   Float_t  x         = gPad->PadtoX(upx);
1332   
1333   Int_t    setrange  = 0;
1334   
1335   TCanvas* cpad      = 0;
1336   //  Char_t   namehist[50];
1337   TString   projhist;
1338   TString   namesel;
1339   TString   namecanv;
1340   
1341   Int_t    xbinmin  = 0;
1342   Int_t    xbinmax  = 0;
1343   Float_t  ybinmin  = 0;
1344   Float_t  ybinmax  = 0;
1345   Int_t    rocid     = 0;
1346   // Check wich Canvas executed the event
1347   TH2S* fHistIndex=0;
1348   namesel=select->GetName();
1349   if(namesel=="fHistOROC" || namesel=="fHistOROCRMS" || namesel=="fHistOROCTime" )
1350   {
1351     rocid = 1;
1352     fPadUsedRoc =1;
1353     projhist=Form("ProjectionOROC");
1354     namecanv=Form("coroc_ch");
1355     fHistIndex = fHistOROCIndex;
1356   }
1357   if(namesel=="fHistIROC" || namesel=="fHistIROCRMS" || namesel=="fHistIROCTime" )
1358   {
1359     rocid = 0;
1360     fPadUsedRoc=0;
1361     projhist=Form("ProjectionIROC");
1362     namecanv=Form("ciroc_ch");
1363     fHistIndex = fHistIROCIndex;
1364   }
1365   
1366   // Check if Canvas already existed and get Ranges from former Prjection histogram
1367   if((cpad=(TCanvas*)gROOT->GetListOfCanvases()->FindObject(namecanv)))
1368   {
1369     cpad->cd();
1370     if(gROOT->Get(projhist))
1371     {
1372       setrange = 1;
1373       xbinmin = ((TH1D*)gROOT->Get(projhist))->GetXaxis()->GetFirst();
1374       xbinmax = ((TH1D*)gROOT->Get(projhist))->GetXaxis()->GetLast();
1375       ybinmin = ((TH1D*)gROOT->Get(projhist))->GetMinimum();
1376       ybinmax = ((TH1D*)gROOT->Get(projhist))->GetMaximum();
1377       delete gROOT->Get("legfit");
1378       delete gROOT->Get("fg");
1379     }
1380   }
1381   else
1382   {
1383     cpad = CreateCanvas(namecanv); cpad->cd();
1384   }
1385   
1386   // Get Bin
1387   if (!fHistIndex) return;
1388   Int_t testy = fHistIndex->GetYaxis()->FindBin(y);
1389   Int_t testx = fHistIndex->GetXaxis()->FindBin(x);
1390   Int_t binchannel = (Int_t)fHistIndex->GetCellContent(testx,testy);
1391   if(binchannel>30000 || binchannel<0) return;
1392   
1393   TH1D *hp=(TH1D*)gROOT->Get(projhist);
1394   if(!hp)  hp=new TH1D(projhist,projhist,GetTimeBins(),0,GetTimeBins());//delete gROOT->Get(projhist);
1395   // Get Projection
1396 //   TH1D *hp = (TH1D*)(((TH1D*)fHistChannelTime->ProjectionY("hp",binchannel,binchannel))->Clone(projhist));
1397 //   TH1D *hp = fHistChannelTime->ProjectionY(projhist,binchannel,binchannel);
1398 //   hp->Reset();
1399   Int_t nbinsx=fHistChannelTime->GetNbinsX();
1400   for (Int_t itb=0;itb<GetTimeBins();++itb){
1401     hp->GetArray()[itb]=fHistChannelTime->GetArray()[binchannel+itb*(nbinsx+2)];
1402   }
1403 //   printf("hi\n");
1404 //   return;
1405   
1406   // Make title and Pave for channel Info
1407   Int_t npadRow , npad  , nhw , nmax , hwadd;
1408   
1409   hwadd   = (Int_t)fHistChannelTime->GetCellContent(binchannel,0);
1410   fPadUsedHwAddr = hwadd;
1411   
1412   if(rocid==0)npadRow = fMapHand->GetPadRow(hwadd);
1413   else        npadRow = fMapHand->GetPadRow(hwadd)-63;
1414   npad                = fMapHand->GetPad(hwadd);
1415   nhw                 = hwadd;
1416   nmax                = (Int_t)hp->GetMaximum();
1417   
1418   
1419   TPaveText*  legstat = new TPaveText(0.18,0.65,0.3,0.8,"NDC");
1420   
1421   Int_t   connector   =  fMapHand->GetFECconnector(hwadd);
1422   Int_t   fecnr       =  fMapHand->GetFECfromHw(hwadd);
1423   Int_t   fecch       =  fMapHand->GetFECchannel(hwadd);
1424   Int_t   altrochip   =  fMapHand->GetAltro(hwadd);
1425   Int_t   altrochannel=  (fMapHand->GetAltroChannel(hwadd))%16;
1426   Int_t   fecloc      =  fMapHand->U2fGetFECinRCU(fecnr) ;
1427   Int_t   feclocbran  =  fMapHand->U2fGetFECinBranch(fecnr);
1428   Int_t   branch      =  fMapHand->U2fGetBranch(fecnr);
1429   
1430   
1431   Short_t fecget      = (hwadd & fgkHwMaskFEC)   >> 7;
1432   Short_t branchget   = (hwadd & fgkHwMaskBranch)>> 11;
1433   
1434   legstat->AddText(Form("Branch (map) \t %i (%i) \n",branchget,branch));
1435   legstat->AddText(Form("Fec in patch \t %i \n",fecloc));
1436   legstat->AddText(Form("Fec in branch (map)\t %i (%i)\n",fecget,feclocbran));
1437   legstat->AddText(Form("Connector  \t %i \n",connector));
1438   legstat->AddText(Form("Fec No.   \t %i \n",fecnr));
1439   legstat->AddText(Form("Fec chan  \t %i \n",fecch));
1440   legstat->AddText(Form("Altro chip\t %i \n",altrochip));
1441   legstat->AddText(Form("Altro chan\t %i \n",altrochannel));
1442   
1443   TString title=Form("Row=%d Pad=%d Hw =%d maxADC =%d count =%d",npadRow,npad,nhw,nmax,binchannel);
1444   
1445 //   hp->SetName(projhist);
1446   hp->SetTitleSize(0.04);
1447   hp->SetTitle(title.Data());
1448   hp->SetYTitle("ADC");
1449   hp->SetXTitle("Timebin");
1450   hp->GetXaxis()->SetTitleColor(1);
1451   
1452   if(setrange)
1453   {
1454     hp->GetXaxis()->SetRange(xbinmin,xbinmax);
1455     hp->SetMinimum(ybinmin);
1456     hp->SetMaximum(ybinmax);
1457   }
1458   else
1459   {
1460     hp->SetMinimum(0.0);
1461     hp->SetMaximum(1000.0);
1462   }
1463   
1464   cpad->cd();
1465   hp->Draw();
1466   
1467   // Make Fit to peak
1468   if(GetPedestals() && fDisableFit==0)
1469   {
1470     Int_t maxx  =    (Int_t)fHistAddrMaxAdcX->GetBinContent(hwadd);
1471     Float_t max  =  (Float_t)fHistAddrMaxAdc->GetBinContent(hwadd);
1472     Float_t base =  (Float_t)fHistAddrBaseMean->GetBinContent(hwadd);
1473     if(base!=0)
1474     {
1475       if( ((max+base)/base)>1.2)
1476       {
1477         TF1* fg = new TF1("fg",AliTPCMonitor::Gamma4,maxx-5,maxx+5,4);
1478         fg->SetParName(0,"Normalisation");
1479         fg->SetParName(1,"Minimum");
1480         fg->SetParName(2,"Width");
1481         fg->SetParName(3,"Base");
1482         fg->SetParameter(0,max);
1483         fg->SetParameter(1,maxx-2);
1484         fg->SetParameter(2,1.5);
1485         fg->FixParameter(3,0);
1486         fg->SetLineColor(4);
1487         fg->SetLineWidth(1);
1488         hp->Fit("fg","RQ");
1489         
1490         TLegend* legfit = new TLegend(0.6,0.7,0.7,0.8);
1491         legfit->AddEntry("fg","#Gamma 4 fit","l");
1492         legfit->SetFillColor(0);
1493         legfit->SetName("legfit");
1494         legfit->Draw("same");
1495       }
1496     }
1497   }
1498   legstat->SetFillColor(0);
1499   legstat->Draw("same");
1500   cpad->Update();
1501   return;
1502 }
1503
1504 //__________________________________________________________________
1505 void AliTPCMonitor::ExecRow() 
1506 {
1507   
1508   // Executable for Pad
1509   // Show profile of max adc over given pad row
1510   // and 2dim histo  adc(pad-in-row,time bin)
1511   
1512   Int_t event = gPad->GetEvent();
1513   if (event != 61)    return;
1514   gPad->cd();
1515   TObject *select = gPad->GetSelected();
1516   if(!select)    return;
1517   if(!select->InheritsFrom("TH2")) {   return;  }
1518   
1519   Int_t rocid = 0;
1520   
1521   const Char_t *rowhist="hrowtime";
1522   const Char_t *rowhistxmax="hxmax";
1523   const Char_t *rowhistmax="hrowmax";
1524   
1525   // get position
1526   Int_t   px  = gPad->GetEventX();
1527   Int_t   py  = gPad->GetEventY();
1528   Float_t upy = gPad->AbsPixeltoY(py);
1529   Float_t upx = gPad->AbsPixeltoX(px);
1530   Float_t y   = gPad->PadtoY(upy);
1531   Float_t x   = gPad->PadtoX(upx);
1532   
1533   TCanvas*crowtime   = 0;
1534   TCanvas*crowmax    = 0;
1535   TCanvas*cxmax      = 0;
1536   
1537   TH2S*  fHistIndex  = 0;
1538   
1539   // ranges from already existing histos
1540   Int_t    rowtimexmin = 0;
1541   Int_t    rowtimexmax = 0;
1542   Int_t    rowtimeymin = 0;
1543   Int_t    rowtimeymax = 0;
1544   Float_t  rowtimezmin = 0;
1545   Float_t  rowtimezmax = 0;
1546   
1547   Int_t    profrowxmin = 0;
1548   Int_t    profrowxmax = 0;
1549   Double_t profrowymin = 0;
1550   Double_t profrowymax = 0;
1551   
1552   Int_t    profxxmin   = 0;
1553   Int_t    profxxmax   = 0;
1554   Double_t profxymin   = 0;
1555   Double_t profxymax   = 0;
1556   
1557   
1558   Int_t    setrange      = 0;
1559   
1560   TString name=select->GetName();
1561   if(     name=="fHistIROC" || name=="fHistIROCRMS" ) { fHistIndex = fHistIROCIndex;     rocid =1;   }
1562   else if(name=="fHistOROC" || name=="fHistOROCRMS" ) { fHistIndex = fHistOROCIndex;     rocid =2;   }
1563   else  { cout << " not implemented for this histo " << endl; return; }
1564   
1565   gPad->GetCanvas()->FeedbackMode(kTRUE);
1566   
1567   
1568   
1569   // check if canvases exist //
1570   crowtime  = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("crowtime");
1571   crowmax   = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("crowmax");
1572   cxmax     = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("cxmax");
1573   
1574   if(!crowtime)   crowtime   = CreateCanvas("crowtime") ;
1575   if(!crowmax)    crowmax    = CreateCanvas("crowmax")  ;
1576   if(!cxmax  )    cxmax      = CreateCanvas("cxmax")    ;
1577   
1578   // check ranges of already existing histos
1579   if(gROOT->Get(rowhist))
1580   {
1581     rowtimexmin  = ((TH2F*)gROOT->Get(rowhist))->GetXaxis()->GetFirst();
1582     rowtimexmax  = ((TH2F*)gROOT->Get(rowhist))->GetXaxis()->GetLast();
1583     rowtimeymin  = ((TH2F*)gROOT->Get(rowhist))->GetYaxis()->GetFirst();
1584     rowtimeymax  = ((TH2F*)gROOT->Get(rowhist))->GetYaxis()->GetLast();
1585     rowtimezmin  = ((TH2F*)gROOT->Get(rowhist))->GetMinimum();
1586     rowtimezmax  = ((TH2F*)gROOT->Get(rowhist))->GetMaximum();
1587     
1588     profrowxmin  = ((TH1F*)gROOT->Get(rowhistmax))->GetXaxis()->GetFirst();
1589     profrowxmax  = ((TH1F*)gROOT->Get(rowhistmax))->GetXaxis()->GetLast();
1590     profrowymin  = ((TH1F*)gROOT->Get(rowhistmax))->GetMinimum();
1591     profrowymax  = ((TH1F*)gROOT->Get(rowhistmax))->GetMaximum();
1592     
1593     profxxmin    = ((TH1F*)gROOT->Get(rowhistxmax))->GetXaxis()->GetFirst();
1594     profxxmax    = ((TH1F*)gROOT->Get(rowhistxmax))->GetXaxis()->GetLast();
1595     profxymin    = ((TH1F*)gROOT->Get(rowhistxmax))->GetMinimum();
1596     profxymax    = ((TH1F*)gROOT->Get(rowhistxmax))->GetMaximum();
1597     
1598     setrange =1;
1599     
1600     delete gROOT->Get(rowhist);
1601     delete gROOT->Get(rowhistmax);
1602     delete gROOT->Get("hxmax");
1603     delete gROOT->Get("legrow");
1604   }
1605   
1606   // get channel for xy bin -> getRow -> getNrows -> getHw for each Pad in Row -> get channel for each hw -> make proj
1607   Int_t testy      = fHistIndex->GetYaxis()->FindBin(y);
1608   Int_t testx      = fHistIndex->GetXaxis()->FindBin(x);
1609   Int_t binchannel = (Int_t)fHistIndex->GetCellContent(testx,testy);
1610   
1611   if(binchannel>30000)    return;
1612   if(binchannel<=0 ) { crowtime->Update() ;    crowmax->Update() ;    return ;  }
1613   
1614   // get hwaddress
1615   Int_t hwadd     = (Int_t)fHistChannelTime->GetCellContent(binchannel,0);
1616   Int_t row       = fMapHand->GetPadRow(hwadd);
1617   Int_t pad       = fMapHand->GetPad(hwadd)   ;
1618   Int_t numofpads =  fMapHand->GetNumofPads(row);
1619   
1620   // create histos
1621   TH2F *hrowtime = new TH2F(rowhist     , ""  ,numofpads,0,numofpads,GetTimeBins(),0.0,GetTimeBins());
1622   TH1F *hrowmax  = new TH1F(rowhistmax , ""  ,numofpads,0,numofpads);
1623   TH1F *hxmax    = new TH1F(rowhistxmax, ""  ,159,0,159      );
1624   
1625   // Row profile ///////////
1626   if(fVerb) cout << " Number of pads " << numofpads << endl;
1627   for(Int_t padnr = 0; padnr<numofpads;padnr++)
1628   {
1629     Int_t addrinrow = fMapHand->GetPadAddInRow(row,padnr );
1630     Int_t channel   = (Int_t)fHistAddrMapIndex->GetBinContent(addrinrow);
1631     if(channel==-1) continue;
1632     
1633     hrowmax->SetBinContent(padnr+1,fHistAddrMaxAdc->GetBinContent(addrinrow));
1634     TH1D *hp = fHistChannelTime->ProjectionY("hp",channel,channel);
1635     for(Int_t time = 0;time<GetTimeBins();time++) {
1636       
1637       Float_t val = hp->GetBinContent(time);
1638       hrowtime->SetCellContent(padnr+1,time+1,val);
1639     }
1640   }
1641   
1642   // X profile  /////////////
1643   Double_t xval  = 0.0;
1644   Double_t yval  = 0.0;
1645   GetXY(xval,yval,numofpads,row,pad);
1646   
1647   Int_t padnr = 0;
1648   Int_t hw    = 0;
1649   for(Int_t nrow = 0; nrow<159; nrow++)
1650   {
1651     padnr = GetPadAtX(xval,nrow);
1652     if(padnr>=0)
1653     {
1654       hw = fMapHand->GetPadAddInRow(nrow,padnr);
1655       if(fPadMapHw[hw]==-1){ continue                                                      ; }
1656       else                { hxmax->SetBinContent(nrow+1,fHistAddrMaxAdc->GetBinContent(hw))   ; }
1657     }
1658   }
1659   
1660   cxmax->cd();
1661   hxmax->SetTitle(Form("max adc in pads at x=%5.1f mm",xval));
1662   hxmax->SetXTitle("row");
1663   if(!GetPedestals()) hxmax->SetYTitle("max adc (baseline sub.)");
1664   else                hxmax->SetYTitle("max adc ");
1665   hxmax->SetMinimum(0.01);
1666   hxmax->Draw("l");
1667   
1668   if(setrange)
1669   {
1670     hxmax->GetXaxis()->SetRange(profxxmin,profxxmax);
1671     hxmax->SetMinimum(profxymin);
1672     hxmax->SetMaximum(profxymax);
1673   }
1674   
1675   cxmax->Update();
1676   
1677   crowtime->cd();
1678   TString title;
1679   TString titlemax;
1680   if(rocid==1) {
1681     title.Form("%s Row=%d",((TH2*)select)->GetTitle(),row)   ;
1682     titlemax.Form("IROC  max/sum Row=%d",row   );
1683   }  else  {
1684     title.Form("%s Row=%d",((TH2*)select)->GetTitle(),row-63);
1685     titlemax.Form("OROC  max/sum Row=%d",row-63);
1686   }
1687   
1688   if(fVerb) cout << " set name " << endl;
1689   
1690   
1691   // row vs time
1692   crowtime->cd();
1693   hrowtime->SetTitleSize(0.04);
1694   hrowtime->SetTitle(title.Data());
1695   hrowtime->SetYTitle("timbin");
1696   hrowtime->SetXTitle("pad in row");
1697   hrowtime->SetZTitle("signal (ADC)");
1698   
1699   hrowtime->GetXaxis()->SetTitleColor(1);
1700   hrowtime->SetMaximum(1000.0);
1701   hrowtime->SetMinimum(0.0);
1702   
1703   if(setrange)
1704   {
1705     hrowtime->GetXaxis()->SetRange(rowtimexmin,rowtimexmax);
1706     hrowtime->GetYaxis()->SetRange(rowtimeymin,rowtimeymax);
1707     hrowtime->SetMinimum(rowtimezmin);
1708     hrowtime->SetMaximum(rowtimezmax);
1709   }
1710   
1711   hrowtime->Draw("COLZ");
1712   crowtime->UseCurrentStyle();
1713   crowtime->Update();
1714   
1715   // max and sum /////////////////////////
1716   crowmax->cd();
1717   if(setrange) {
1718     hrowmax->GetXaxis()->SetRange(profrowxmin,profrowxmax);
1719     hrowmax->SetMinimum(profrowymin);
1720     hrowmax->SetMaximum(profrowymax);
1721   }
1722   hrowmax->SetTitleSize(0.04);
1723   hrowmax->SetTitle(title.Data());
1724   hrowmax->SetYTitle("max adc");
1725   hrowmax->SetXTitle("pad in row");
1726   hrowmax->GetXaxis()->SetTitleColor(1);
1727   
1728   hrowmax->SetLineColor(2);
1729   hrowmax->Draw("l");
1730   crowmax->Update();
1731   
1732   return;
1733 }
1734
1735 //__________________________________________________________________
1736 void AliTPCMonitor::Write10bitChannel()
1737 {
1738   
1739   // Write 10 bit words form histogram for active(last pointed)  channel
1740   
1741   if(fPadUsedHwAddr==-1){ AliWarning(" No active pad "); return ;}
1742   
1743   Int_t  pad     = (Int_t)fMapHand->GetPad(   fPadUsedHwAddr);
1744   Int_t  row     = (Int_t)fMapHand->GetPadRow(fPadUsedHwAddr);
1745   Int_t  channel = (Int_t)fPadMapHw[fPadUsedHwAddr];
1746   
1747   TString filenameroot;
1748   TString filenamedat;
1749   TString projhist;
1750   
1751   if(fPadUsedRoc==1) { projhist.Form("ProjectionOROC"); }
1752   if(fPadUsedRoc==0) { projhist.Form("ProjectionIROC"); }
1753   
1754   filenamedat.Form("Channel_Run%05i_EventID_%i_Pad_%i_Row_%i.dat"      ,fRunId,fEventNumber,pad,row);
1755   filenameroot.Form("Channel_Run%05i_EventID_%i_Pad_%i_Row_%i.root"     ,fRunId,fEventNumber,pad,row);
1756   
1757   TH1D* hpr = 0;
1758   if((hpr=(TH1D*)gROOT->Get(projhist)))
1759   {
1760       // root histo
1761     TFile f(filenameroot.Data(),"recreate");
1762     hpr->Write();
1763     f.Close();
1764     
1765       // raw singal
1766     ofstream datout(filenamedat.Data(),ios::out);
1767     datout <<"Timebin \t ADC value " << endl;
1768     for(Int_t i = 1; i <GetTimeBins(); i++)
1769     {
1770       datout << i << " \t \t " << fPad[channel][i] << endl;
1771     }
1772     datout.close();
1773   }
1774   else
1775   {
1776     AliWarning("No projection histo found ");
1777   }
1778 }
1779
1780 //__________________________________________________________________
1781 void AliTPCMonitor::ExecTransform() 
1782 {
1783   
1784   // Make Fast Fourier Transformation for active pad
1785   // fft is only performed for a data sample of size 2^n
1786   // reduce window according to largest  power of 2 which is smaller than the viewing  range
1787   
1788   TString namecanv;
1789   TString namecanv2;
1790   TString projhist;
1791   TString namehtrimag;
1792   TString namehtrreal;
1793   TString namehtrmag;
1794   
1795   if(fPadUsedRoc==1) {    namecanv="coroc_ch_trans"; namecanv2="coroc_ch_trans2";  projhist="ProjectionOROC";  }
1796   if(fPadUsedRoc==0) {    namecanv="ciroc_ch_trans"; namecanv2="ciroc_ch_trans2";  projhist="ProjectionIROC";  }
1797   
1798   TH1D*  hproj = 0;
1799   
1800   if((TH1D*)gROOT->Get(projhist)==0){AliWarning("Proj histo does not exist \n Move mouse over 2d histo choose channel \n and drag mouse form histo again!");  return ;}
1801   else      hproj = (TH1D*)gROOT->Get(projhist.Data()) ;
1802   
1803   
1804   if(fPadUsedRoc==1) {  namehtrimag="htransimagfreq_oroc";    namehtrreal="htransrealfreq_oroc"; namehtrmag="htransmagfreq_oroc";  }
1805   else               {  namehtrimag="htransimagfreq_iroc";    namehtrreal="htransrealfreq_iroc"; namehtrmag="htransmagfreq_iroc";  }
1806   
1807   if( gROOT->Get(namehtrimag.Data()))  delete  gROOT->Get(namehtrimag.Data());
1808   if( gROOT->Get(namehtrreal.Data()))  delete  gROOT->Get(namehtrreal.Data());
1809   if( gROOT->Get(namehtrmag.Data()))  delete  gROOT->Get(namehtrmag.Data());
1810   
1811   TCanvas *ctrans = 0;
1812   if(!(ctrans = (TCanvas*)gROOT->GetListOfCanvases()->FindObject(namecanv.Data())))
1813   {
1814     ctrans = CreateCanvas(namecanv.Data());
1815     ctrans->Divide(1,2);
1816   }
1817   TCanvas *ctrans2 = 0;
1818   if(!(ctrans2 = (TCanvas*)gROOT->GetListOfCanvases()->FindObject(namecanv2.Data())))
1819   {
1820     ctrans2 = CreateCanvas(namecanv2.Data());
1821 //      ctrans2->Divide(1,2);
1822   }
1823   
1824   Int_t binfirst  =  hproj->GetXaxis()->GetFirst();
1825   Int_t binlast   =  hproj->GetXaxis()->GetLast();
1826   Int_t bins       =  binlast -binfirst +1;
1827   
1828   Int_t power = 0;
1829   for(Int_t pot = 0; pot<=10 ; pot++)
1830   {
1831     Int_t comp =  (Int_t)TMath::Power(2,pot);
1832     if(bins>=comp)power = pot;
1833   }
1834   
1835   bins = (Int_t)TMath::Power(2,power);
1836   
1837   // sampling frequency ;
1838   Double_t  deltat = 1.0/(Float_t)GetSamplingFrequency();
1839   
1840   // output histo
1841   TH1D* htransrealfreq = new TH1D(namehtrreal.Data(),namehtrreal.Data(),10000,-1/(2*deltat),1/(2*deltat));
1842   TH1D* htransimagfreq = new TH1D(namehtrimag.Data(),namehtrimag.Data(),10000,-1/(2*deltat),1/(2*deltat));
1843   TH1D* htransmag      = new TH1D(namehtrmag.Data(),namehtrmag.Data(),10000,-1/(2*deltat),1/(2*deltat));
1844   
1845   TString titlereal;
1846   TString titleimag;
1847   TString titlemag;
1848   if(fPadUsedRoc==1) {    titlereal="OROC DFT real part";  titleimag="OROC DFT imag part";  titlemag="OROC DFT magnitude";  }
1849   else {                  titlereal="IROC DFT real part";  titleimag="IROC DFT imag part";  titlemag="IROC DFT magnitude";  }
1850   
1851   htransrealfreq->SetTitle(titlereal.Data());  htransrealfreq->SetXTitle("f/hz");  htransrealfreq->SetYTitle("z_{real}(f)");
1852   htransimagfreq->SetTitle(titleimag.Data());  htransimagfreq->SetXTitle("f/hz");  htransimagfreq->SetYTitle("z_{imag}(f)");
1853   htransmag->SetTitle(titlemag.Data());  htransmag->SetXTitle("f/hz");  htransmag->SetYTitle("mag(f)");
1854   
1855   // create complex packed data array
1856   const Int_t kdatasiz = 2*bins;
1857   Double_t*  data = new Double_t[kdatasiz];
1858   for(Int_t i=0;i<2*bins;i++)  { data[i]   =  0.0;}
1859   for(Int_t i=0;i<bins;i++)    { data[2*i] = (Double_t)hproj->GetBinContent(binfirst+i); }
1860   
1861   // make fourier transformation
1862   AliTPCMonitorFFT* four = new AliTPCMonitorFFT();
1863   four->ComplexRadix2ForwardWrap(data,1,bins);
1864   
1865   // write output  and fill histos forward
1866   Double_t freq =  0.0;
1867   for(Int_t i=0;i<2*bins;i++)
1868   {
1869     if(i<bins)
1870     {
1871       if(i<(bins/2))  { freq = i/(bins*deltat)            ; }
1872       else            { freq = -1*((bins-i)/(bins*deltat)); }
1873       htransrealfreq->Fill( freq,data[2*i]  );
1874       htransimagfreq->Fill( freq,data[2*i+1]);
1875       htransmag->Fill( freq, TMath::Sqrt(data[2*i]*data[2*i]+data[2*i+1]*data[2*i+1]) );
1876     }
1877   }
1878   
1879   ctrans->cd(1);
1880   htransrealfreq->Draw();
1881   ctrans->cd(2);
1882   htransimagfreq->Draw();
1883   ctrans->Update();
1884   ctrans2->cd();
1885   htransmag->Draw();
1886   ctrans2->Update();
1887   delete four;
1888   delete [] data;
1889 }
1890
1891 //__________________________________________________________________
1892 void AliTPCMonitor::ShowSel(Int_t* compval)               
1893 {
1894   
1895   // Show only selected components
1896   // First restore original histogram from clone
1897   // Than remove all not matching pads form histos
1898   
1899   Int_t   connector   =  0;
1900   Int_t   fecnr       =  0;
1901   Int_t   altrochip   =  0;
1902   Int_t   feclocbran  =  0;
1903   Int_t   branch      =  0;
1904   Short_t rcuget      =  0;
1905   Int_t   emptyI      =  1;
1906   Int_t   index       = -1;
1907   Int_t   hwadd       =  0;
1908   
1909   Float_t maxiroc     =  fHistIROCClone->GetMaximum();
1910   Float_t maxoroc     =  fHistOROCClone->GetMaximum();
1911   
1912   
1913   //  restore original histos
1914   for(Int_t row = 0; row<fkNRowsIroc;  row++)
1915   {
1916     for(Int_t pad = 0; pad<fkNPadsIroc;  pad++)
1917     {
1918       index = (Int_t)fHistIROCIndex->GetCellContent(row+1,pad+1);
1919       if(index==-1)continue;
1920       else  fHistIROC->SetCellContent(row+1,pad+1,fHistIROCClone->GetCellContent(row+1,pad+1));
1921     }
1922   }
1923   for(Int_t row = 0; row<fkNRowsOroc;  row++)
1924   {
1925     for(Int_t pad = 0; pad<fkNPadsOroc;  pad++)
1926     {
1927       index = (Int_t)fHistOROCIndex->GetCellContent(row+1,pad+1);
1928       if(index==-1)continue;
1929       else    fHistOROC->SetCellContent(row+1,pad+1,fHistOROCClone->GetCellContent(row+1,pad+1));
1930     }
1931   }
1932   
1933   
1934   // remove not matching entries from fHistIROC/fHistOROC
1935   
1936   TH2F* fHist       =0;
1937   TH2S* fHistIndex  =0;
1938   Int_t npads       =0;
1939   Int_t subrows     =0;
1940   
1941   for(Int_t row = 0; row< (fkNRowsIroc + fkNRowsOroc);  row++)
1942   {
1943     if(row<fkNRowsIroc) {  fHist=fHistIROC ; fHistIndex = fHistIROCIndex; npads = fkNPadsIroc; subrows =0         ;}
1944     else                {  fHist=fHistOROC ; fHistIndex = fHistOROCIndex; npads = fkNPadsOroc; subrows =fkNRowsIroc;}
1945     
1946     for(Int_t pad = 0; pad<npads;  pad++)
1947     {
1948       index    = (Int_t)fHistIndex->GetCellContent(row -subrows +1,pad+1);
1949       if(index==-1)  continue ;
1950       hwadd    = (Int_t)fHistChannelTime->GetCellContent(index,0);
1951       
1952     // global fecnr
1953       fecnr     =  fMapHand->GetFECfromHw(hwadd);
1954       if(compval[0]!=-1 && fecnr!=compval[0])      {      fHist->SetCellContent(row-subrows+1,pad+1,0);           continue;     }
1955       
1956     // rcu
1957       rcuget      = (hwadd & fgkHwMaskRCU)>> 12;
1958       if(compval[1]!=-1 && rcuget!=compval[1])     {      fHist->SetCellContent(row-subrows+1,pad+1,0);           continue;     }
1959       
1960     // branch
1961       branch    =  fMapHand->U2fGetBranch(fecnr) ;
1962       if(compval[2]!=-1 && branch!=compval[2])     {      fHist->SetCellContent(row-subrows+1,pad+1,0);           continue;     }
1963       
1964     // local fec
1965       feclocbran=   fMapHand->U2fGetFECinBranch(fecnr) ;
1966       if(compval[3]!=-1 && feclocbran!=compval[3]) {      fHist->SetCellContent(row-subrows+1,pad+1,0);           continue;     }
1967       
1968     // connector
1969       connector =  fMapHand->GetFECconnector(hwadd);
1970       if(compval[4]!=-1 && connector!=compval[4])  {      fHist->SetCellContent(row-subrows+1,pad+1,0);           continue;     }
1971       
1972     // Altro chip
1973       altrochip     =  fMapHand->GetAltro(hwadd);
1974       if(compval[5]!=-1 && altrochip!=compval[5])      {          fHist->SetCellContent(row-subrows+1,pad+1,0);           continue;     }
1975       emptyI =0;
1976     }
1977   }
1978   
1979   TCanvas* c1 =0;
1980   TCanvas* c2 =0;
1981   if(gROOT->GetListOfCanvases()->FindObject("ciroc"))
1982   {
1983     c1 = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("ciroc");
1984     c1->cd() ;
1985     fHistIROC->Draw("COLZ");
1986     fHistIROC->SetMaximum(maxiroc);
1987     fHistIROC->SetMinimum(0.0);
1988     c1->Update();
1989   }
1990   if(gROOT->GetListOfCanvases()->FindObject("coroc"))
1991   {
1992     c2 =  (TCanvas*)gROOT->GetListOfCanvases()->FindObject("coroc");
1993     c2->cd() ;
1994     fHistOROC->Draw("COLZ");
1995     fHistOROC->SetMaximum(maxoroc);
1996     fHistOROC->SetMinimum(0.0);
1997     c2->Update();
1998   }
1999   return ;
2000 }
2001
2002 //__________________________________________________________________
2003 void AliTPCMonitor::ResizeCanv() 
2004 {
2005   // Resize canvases and delete some of them
2006   
2007   TString carry1=Form(".x %s/TPC/AliTPCMonitorExec.C(1)",gSystem->Getenv("ALICE_ROOT"));
2008   TString carry3=Form(".x %s/TPC/AliTPCMonitorExec.C(2)",gSystem->Getenv("ALICE_ROOT"));
2009   if(fVerb) cout <<  " canv 1 " << endl;
2010   
2011   if(gROOT->GetListOfCanvases()->FindObject(        "coroc_ch")) {  delete gROOT->GetListOfCanvases()->FindObject("coroc_ch") ; }
2012   if(gROOT->GetListOfCanvases()->FindObject(        "ciroc_ch")) {  delete gROOT->GetListOfCanvases()->FindObject("ciroc_ch") ; }
2013   
2014   // for 2dim plots delete create and draw again
2015   if(gROOT->GetListOfCanvases()->FindObject("ciroc"))
2016   {
2017     delete  gROOT->GetListOfCanvases()->FindObject("ciroc");
2018     TCanvas* ciroc = CreateCanvas("ciroc");
2019     ciroc->cd();
2020     fHistIROC->Draw("COLZ");
2021     ciroc->AddExec("pad",carry1.Data());
2022     ciroc->AddExec("row",carry3.Data());
2023     fExecPlaneMax=1;
2024     ciroc->Update();
2025   }
2026   // for 2dim plots delete create and draw again
2027   if(gROOT->GetListOfCanvases()->FindObject("coroc"))
2028   {
2029     delete gROOT->GetListOfCanvases()->FindObject("coroc");
2030     TCanvas* coroc = CreateCanvas("coroc");
2031     coroc->cd();
2032     fHistOROC->Draw("COLZ");
2033     
2034     coroc->AddExec("pad",carry1.Data());
2035     coroc->AddExec("row",carry3.Data());
2036     coroc->Update();
2037     fExecPlaneMax=1;
2038   }
2039   
2040   if(gROOT->GetListOfCanvases()->FindObject(       "cbasemean")) {    delete gROOT->GetListOfCanvases()->FindObject("cbasemean"); }
2041   if(gROOT->GetListOfCanvases()->FindObject(           "cbase")) {    delete gROOT->GetListOfCanvases()->FindObject("cbase");}
2042   if(gROOT->GetListOfCanvases()->FindObject(        "cbaserms")) {    delete gROOT->GetListOfCanvases()->FindObject("cbaserms");  }
2043   if(gROOT->GetListOfCanvases()->FindObject(            "cmax")) {    delete gROOT->GetListOfCanvases()->FindObject("cmax");      }
2044   if(gROOT->GetListOfCanvases()->FindObject(            "csum")) {    delete gROOT->GetListOfCanvases()->FindObject("csum");      }
2045   if(gROOT->GetListOfCanvases()->FindObject(  "ciroc_ch_trans")) {    delete gROOT->GetListOfCanvases()->FindObject("ciroc_ch_trans");}
2046   if(gROOT->GetListOfCanvases()->FindObject(  "coroc_ch_trans")) {    delete gROOT->GetListOfCanvases()->FindObject("coroc_ch_trans");}
2047   if(gROOT->GetListOfCanvases()->FindObject(       "crowtime")) {    delete gROOT->GetListOfCanvases()->FindObject("crowtime"); }
2048   if(gROOT->GetListOfCanvases()->FindObject(        "crowmax")) {    delete gROOT->GetListOfCanvases()->FindObject("crowmax");  }
2049   if(gROOT->GetListOfCanvases()->FindObject(          "cxmax")) {    delete gROOT->GetListOfCanvases()->FindObject("cxmax");    }
2050   if(gROOT->GetListOfCanvases()->FindObject(        "crmsoroc")) {    delete gROOT->GetListOfCanvases()->FindObject("crmsoroc");         fExecPadOrocRms = 0;   }
2051   if(gROOT->GetListOfCanvases()->FindObject(        "crmsiroc")) {    delete gROOT->GetListOfCanvases()->FindObject("crmsiroc");         fExecPadIrocRms = 0;   }
2052   if(gROOT->GetListOfCanvases()->FindObject(        "crowmax")) {    delete gROOT->GetListOfCanvases()->FindObject("crowmax");  }
2053   if(gROOT->GetListOfCanvases()->FindObject(        "crowmax")) {    delete gROOT->GetListOfCanvases()->FindObject("crowmax");  }
2054   
2055 }
2056
2057
2058
2059
2060 //__________________________________________________________________
2061 Int_t AliTPCMonitor::ExecProcess() 
2062 {
2063   // Executable for global Histogram
2064   // Will be called from /TPC/AliTPCMonitorExec.C(3)
2065   // Call ProcessEvent for same event and sector pointed at
2066   
2067   Int_t side   = 0;
2068   Int_t sector = 0;
2069   
2070   Int_t event = gPad->GetEvent();
2071   if(event != 61)  return -1;
2072   
2073   TObject *select = gPad->GetSelected();
2074   if(!select)  return -1;
2075   TString name=select->GetName();
2076   if(!select->InheritsFrom("TH2")) {gPad->SetUniqueID(0);    return -1;  }
2077   if(       name=="hglobal"  || name=="SIDE A"  ) side = 0;
2078   else  if( name=="hglobal2" || name=="SIDE C"  ) side = 1;
2079   
2080   // get position
2081   Int_t   px    = gPad->GetEventX();
2082   Int_t   py    = gPad->GetEventY();
2083   Float_t upy   = gPad->AbsPixeltoY(py);
2084   Float_t upx   = gPad->AbsPixeltoX(px);
2085   Float_t y     = gPad->PadtoY(upy);
2086   Float_t x     = gPad->PadtoX(upx);
2087   
2088   Int_t testy = ((TH2*)select)->GetYaxis()->FindBin(y);
2089   Int_t testx = ((TH2*)select)->GetXaxis()->FindBin(x);
2090   if(((TH2*)select)->GetCellContent(testx,testy)==0) return -1 ;
2091   
2092   Float_t alpha = 0.0;
2093   if(x>0.0 && y > 0.0)    alpha = TMath::Abs(TMath::ATan(TMath::Abs(x/y)));
2094   if(x>0.0 && y < 0.0)    alpha = TMath::Abs(TMath::ATan(TMath::Abs(y/x)));
2095   if(x<0.0 && y < 0.0)    alpha = TMath::Abs(TMath::ATan(TMath::Abs(x/y)));
2096   if(x<0.0 && y > 0.0)    alpha = TMath::Abs(TMath::ATan(TMath::Abs(y/x)));
2097   
2098   if(x>0.0 && y < 0.0)    alpha += (    TMath::Pi()/2);
2099   if(x<0.0 && y < 0.0)    alpha += (    TMath::Pi());
2100   if(x<0.0 && y > 0.0)    alpha += (1.5*TMath::Pi());
2101   
2102   sector =   (Int_t)(alpha/(2*TMath::Pi()/18.0));
2103   if(alpha> (sector+0.5)*(2*TMath::Pi()/18.0))  sector+=1;
2104   
2105   if(sector==18 && side ==0 ) {
2106     AliWarning("There was a wromg assignment of sector 0 with sector 18. Check sectors");
2107     sector =0;
2108   }
2109   
2110   sector = (18-sector +4)%18;
2111   SetLastSector(sector+ side*18);
2112   SetProcNextEvent(0);
2113   
2114   if(fVerb) cout << "AliTPCMonitor::ExecProcess()  next side          " <<   side    << " next sector        " <<    sector  << endl;
2115   
2116   return (Int_t)ProcessEvent();
2117   
2118 }
2119
2120 //__________________________________________________________________
2121 Int_t AliTPCMonitor::GetRCUPatch(Int_t runid, Int_t eqid) const
2122 {
2123   
2124   // Return RCU patch index for given equipment id eqid
2125   Int_t patch = 0;
2126   //if(runid>=704)
2127   if(runid>=0)
2128   {
2129     if ( eqid<768 || eqid>983 ) return 0; //no TPC eqid
2130 //     if(eqid>=1000) return 0;
2131     patch = fMapEqidsRcu[eqid] ;
2132   }
2133   else
2134   {
2135     if(eqid==408) {patch =  13*6+4 +0;  }
2136     if(eqid==409) {patch =  13*6+5 +0;  }
2137     if(eqid==509) {patch =  13*6+0 +0;  }
2138     if(eqid==512) {patch =  13*6+3 +0;  }
2139     if(eqid==513) {patch =  13*6+1 +0;  }
2140     if(eqid==517) {patch =  13*6+2 +0;  }
2141     
2142     if(eqid==404) {patch =  4*6+5 +0;   }
2143     if(eqid==504) {patch =  4*6+4 +0;   }
2144     if(eqid==407) {patch =  4*6+3 +0;   }
2145     if(eqid==503) {patch =  4*6+2 +0;   }
2146     if(eqid==508) {patch =  4*6+1 +0;   }
2147     if(eqid==506) {patch =  4*6+0 +0;   }
2148   }
2149   return patch;
2150 }
2151
2152 //__________________________________________________________________
2153 void AliTPCMonitor::DumpHeader(AliRawReader * reader) const
2154 {
2155   // Dump Event header for  format
2156   
2157   cout << "EventHeader     : fReader->GetEquipmentSize()            :" << reader->GetEquipmentSize()        << endl;
2158   cout << "EventHeader     : fReader->GetType()                     :" << reader->GetType()                 << endl;
2159   cout << "EventHeader     : fReader->GetRunNumber()                :" << reader->GetRunNumber()            << endl;
2160   cout << "EventHeader     : fReader->GetEventId()                  :" << *(reader->GetEventId())           << endl;
2161   cout << "EventHeader     : fReader->GetLDCId()                    :" << reader->GetLDCId()                << endl;
2162   cout << "EventHeader     : fReader->GetGDCId()                    :" << reader->GetGDCId()                << endl;
2163 }
2164
2165
2166 //__________________________________________________________________
2167 Double_t AliTPCMonitor::Gamma4(Double_t* x, Double_t* par) {
2168   
2169   // Gamma4 function used to fit signals
2170   // Defined in sections: diverging branch set to 0
2171   
2172   Double_t val  = 0.0;
2173   if(x[0] > par[1])
2174     val = par[0]*exp(4.0)* pow((x[0]-par[1])/par[2],4)*exp(-4.0*(x[0]-par[1])/par[2])+ par[3];
2175   else
2176     val = 0;
2177   return val;
2178 }
2179
2180 //__________________________________________________________________
2181 TCanvas* AliTPCMonitor::CreateCanvas(const Char_t* name)
2182 {
2183   // Create Canvases
2184   
2185   TCanvas* canv =0;
2186   
2187   Int_t xoffset  = GetCanvasXOffset();
2188   Int_t xsize    = GetCanvasXSize();
2189   Int_t ysize    = GetCanvasYSize();
2190   Int_t xspace   = GetCanvasXSpace();
2191   Int_t yspace   = GetCanvasYSpace();
2192
2193   TString sname=name;
2194   // ROC 2dim max distribution
2195   if(     sname=="coroc") {    canv   = new TCanvas("coroc"         ,"coroc"      ,                   -1+xoffset,(Int_t)(yspace+0.5*ysize) ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv;  }
2196   else if(sname=="ciroc") {    canv   = new TCanvas("ciroc"         ,"ciroc"      ,                   -1+xoffset,                     0    ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv;  }
2197   // ROC  2dim rms distribution
2198   else if(sname=="crmsoroc") {    canv   = new TCanvas("crmsoroc"      ,"crmsoroc"   ,                   -1+xoffset,(Int_t)(yspace+0.5*ysize) ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv;  }
2199   else if(sname=="crmsiroc") {    canv   = new TCanvas("crmsiroc"      ,"crmsiroc"   ,                   -1+xoffset,                        0 ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv;  }
2200   // Global ADC max Histos
2201   else if(sname=="SIDE C all") {    canv   = new TCanvas("SIDE C all"    ,"SIDE C all" ,   (Int_t)(3*xspace+ xoffset),(Int_t)(yspace+0.5*ysize) ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv;  }
2202   else if(sname=="SIDE A all") {    canv   = new TCanvas("SIDE A all"    ,"SIDE A all" ,   (Int_t)(3*xspace+ xoffset),                        0 ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv;  }
2203   // 1 dim max sum basekine distribution
2204   else if(sname=="cmax") {    canv   = new TCanvas("cmax"          ,"cmax"       ,                   -1+xoffset,                 3*yspace ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv;  }
2205   else if(sname=="csum") {    canv   = new TCanvas("csum"          ,"csum"       ,               xspace+xoffset,                 3*yspace ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv;  }
2206   else if(sname=="cbasemean") {    canv   = new TCanvas("cbasemean"     ,"cbasemean"  ,             2*xspace+xoffset,                 3*yspace ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv;  }
2207   else if(sname=="cbaserms") {    canv   = new TCanvas("cbaserms"      ,"cbaserms"   ,             3*xspace+xoffset,                 3*yspace ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv;  }
2208   // Projections of single channel
2209   else if(sname=="coroc_ch") {    canv   = new TCanvas("coroc_ch"      ,"coroc_ch"   ,   (Int_t)(1.5*xspace+xoffset),(Int_t)(yspace+0.5*ysize),(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv;  }
2210   else if(sname=="ciroc_ch") {    canv   = new TCanvas("ciroc_ch"      ,"ciroc_ch"   ,   (Int_t)(1.5*xspace+xoffset),                       0 ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv;  }
2211   // FFT for single channel
2212   else if(sname=="coroc_ch_trans") {    canv   = new TCanvas("coroc_ch_trans","coroc_ch_trans",(Int_t)(3.0*xspace+xoffset),(Int_t)(yspace+0.5*ysize),(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv;  }
2213   else if(sname=="ciroc_ch_trans") {    canv   = new TCanvas("ciroc_ch_trans","ciroc_ch_trans",(Int_t)(3.0*xspace+xoffset),                       0 ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv;  }
2214   else if(sname=="coroc_ch_trans2") {    canv   = new TCanvas("coroc_ch_trans2","coroc_ch_trans2",(Int_t)(3.0*xspace+xoffset),(Int_t)(yspace+0.5*ysize),(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv;  }
2215   else if(sname=="ciroc_ch_trans2") {    canv   = new TCanvas("ciroc_ch_trans2","ciroc_ch_trans2",(Int_t)(3.0*xspace+xoffset),                       0 ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv;  }
2216   // row profile histograms
2217   else if(sname=="crowtime") {    canv   = new TCanvas("crowtime"     ,"crowtime"  ,              1*xspace+xoffset,         2*yspace +ysize ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv;  }
2218   else if(sname=="crowmax") {    canv   = new TCanvas("crowmax"      ,"crowmax"   ,              2*xspace+xoffset,         2*yspace +ysize ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv;  }
2219   else if(sname=="cxmax") {    canv   = new TCanvas("cxmax"        ,"cxmax"     ,              3*xspace+xoffset,         2*yspace +ysize ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv;  }
2220   else                                      {    cout   << " Warning Canvas name unknown "  << endl;                                                                                                  return 0   ;  }
2221 }
2222
2223 //__________________________________________________________________
2224 void AliTPCMonitor::WriteHistos()  
2225 {
2226   // Writes all available histograms to a file in current directory
2227   // File name will be specified by : sector, side, runid and eventnumber
2228   
2229   if(GetEventProcessed())
2230   {
2231     AliInfo("Write histos to file");
2232     TString name=Form("SIDE_%i_SECTOR_%02i_RUN_%05i_EventID_%06i.root",(GetLastSector()/18),(GetLastSector()%18),fRunId,fEventNumber);
2233     TFile* f = new TFile(name.Data(),"recreate");
2234     for(Int_t i =0; i<fHistList->GetEntries(); i++)
2235     {
2236       if(((TH1*)fHistList->At(i))!=0)
2237       {
2238         ((TH1*)fHistList->At(i))->Write();
2239       }
2240     }
2241     f->ls();
2242     f->Close();
2243   }
2244   else
2245   {
2246     AliError("No Event Processed : Chose Format , File and push 'Next Event' ");
2247   }
2248 }
2249
2250
2251 //__________________________________________________________________
2252 TH1* AliTPCMonitor::GetHisto(char* histname) 
2253 {
2254   
2255   // Returns histogram specified by histname
2256   // check available names for histos in CreateHistos()
2257   
2258   TH1* hist = 0;
2259   if((TH1*)fHistList->FindObject(histname))
2260   {
2261     hist = (TH1*)fHistList->FindObject(histname);
2262   }
2263   else
2264   {
2265     cout << " AliTPCMonitor::GetHisto :: Can not find histo with name " << histname << endl;
2266   }
2267   return hist ;
2268 }