Script supersceeded by AliForwarddNdetaTask.C and
[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       padmax = fMapHand->GetNumofPads(row);
955       if (sector%36>17) fMirror=-1;
956       else fMirror=1;
957       GetXY(xval ,yval , padmax,row ,pad);
958       xdr    =  xval*m11 +yval*m12;
959       ydr    =  xval*m21 +yval*m22;
960       if(hglob->GetBinContent(hglob->GetXaxis()->FindBin(xdr),hglob->GetYaxis()->FindBin(ydr))==0)   hglob->Fill(xdr,ydr,(Int_t)max);
961     }
962   }
963 }
964
965
966 //__________________________________________________________________
967 void AliTPCMonitor::GetXY( Double_t& xval , Double_t& yval , Int_t padmax, Int_t row , Int_t pad) const 
968 {
969   // Get x and y position of pad
970   
971   if(row<63)
972   {
973     xval = fMirror*( 2*padmax -4*pad -2);
974     yval = 852.25 +7.5*row;
975   }
976   else
977   {
978     xval = fMirror*( 3*padmax -6*pad -3);
979     if((row-63)<63) {     yval = 10*(row-63) +1351;     }
980     else              {   yval = 15*(row-63-64)+1993.5; }
981   }
982   
983
984
985 //__________________________________________________________________
986 Int_t AliTPCMonitor::GetPadAtX(Float_t xval, Int_t row, Int_t padmax) const
987 {
988   // Get pad number at given position in x
989   Int_t pad    = 0;
990   
991   if(row<63) {pad = (Int_t)( ( (xval/fMirror) +2 -2*padmax)/-4);}
992   else       {pad = (Int_t)( ( (xval/fMirror) +3 -3*padmax)/-6);}
993   
994   if(pad>=padmax) return -1;
995   else            return pad ;
996   
997 }
998
999 //__________________________________________________________________
1000 Int_t AliTPCMonitor::GetPadAtX(Float_t xval, Int_t row) const
1001 {
1002   
1003  // Get pad number at given position in x
1004   
1005   Int_t padmax = fMapHand->GetNumofPads(row);
1006   Int_t pad    = 0;
1007   
1008   if(row<63) {pad = (Int_t)( ( (xval/fMirror) +2 -2*padmax)/-4);}
1009   else       {pad = (Int_t)( ( (xval/fMirror) +3 -3*padmax)/-6);}
1010   
1011   if(pad>=padmax) return -1;
1012   else            return pad ;
1013   
1014 }
1015
1016 //__________________________________________________________________
1017 void AliTPCMonitor::DrawHists(Int_t histos) 
1018 {
1019   
1020   // Draw sets of histograms
1021   // histos==1 : 2Dim histos for MAX adc  and add executables
1022   // histos==2 : distributions max/rms/sum
1023   // histos==3 : global max adc for specified SideA/C
1024   
1025   
1026   if(fVerb)    cout << " Draw histos " << endl;
1027   TString cside;
1028   if(GetLastSector()/18==0 ) cside="A";
1029   else                       cside="C";
1030   
1031   TString titleSEC  = Form("Sector %i Side %s Run : %05i EventID %i "       ,GetLastSector()%18,cside.Data(),fRunId, fEventNumber);
1032   TString titleEvent= Form("Time <-> Channles  %s"                          ,titleSEC.Data());
1033   TString titleIROC = Form("IROC %s"                                        ,titleSEC.Data());
1034   TString titleOROC = Form("OROC %s"                                        ,titleSEC.Data());
1035   
1036   TString titleMAX  = Form("Max (timebin: %i,%i) %s"                        ,GetRangeMaxAdcMin(),GetRangeMaxAdcMax(),titleSEC.Data());
1037   TString titleSUM  = Form("Sum (timebin: %i,%i) %s"                        ,GetRangeSumMin()   ,GetRangeSumMax()   ,titleSEC.Data());
1038   TString titleBASE = Form("Baseline RMS<->Mean  (timebin: %i-%i) %s"       ,GetRangeBaseMin()  ,GetRangeBaseMax()  ,titleSEC.Data());
1039   TString titleMEAN = Form("Baseline Mean (timebin: %i-%i) %s"              ,GetRangeBaseMin()  ,GetRangeBaseMax()  ,titleSEC.Data());
1040   TString titleRMS  = Form("Baseline RMS (timebin: %i-%i) %s"               ,GetRangeBaseMin()  ,GetRangeBaseMax()  ,titleSEC.Data());
1041   
1042   if(histos==1)
1043   {
1044       // IROC _______________________________________________________________
1045     TCanvas* ciroc = 0;
1046     ciroc = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("ciroc");
1047     if(!ciroc)
1048     {
1049       ciroc = CreateCanvas("ciroc");
1050       fExecPlaneMax=0;
1051     }
1052     ciroc->cd();
1053     
1054     fHistIROC->SetXTitle("row");
1055     fHistIROC->SetYTitle("pad");
1056     if(GetPedestals()) fHistIROC->SetZTitle("max ADC (baseline sub)");
1057     else               fHistIROC->SetZTitle("max ADC ");
1058     fHistIROC->SetTitle(titleIROC.Data());
1059     fHistIROC->SetMinimum(0.01);
1060     fHistIROC->Draw("COLZ");
1061     ciroc->UseCurrentStyle();
1062     
1063     
1064     fHistIROCTime->SetXTitle("row"); fHistIROCTime->SetZTitle("peak time (fit)");       fHistIROCTime->SetYTitle("pad");      fHistIROCTime->SetTitle(titleIROC.Data());
1065     fHistIROCRMS->SetXTitle("row");  fHistIROCRMS->SetZTitle( "baseline rms (ADC)");    fHistIROCRMS->SetYTitle("pad");       fHistIROCRMS->SetTitle(titleIROC.Data());
1066     
1067       // OROC
1068     TCanvas* coroc = 0;
1069     coroc =(TCanvas*)gROOT->GetListOfCanvases()->FindObject("coroc");
1070     if(!coroc) {
1071       coroc = CreateCanvas("coroc");
1072       fExecPlaneMax=0;
1073     }
1074     coroc->cd();
1075     
1076     fHistOROC->SetXTitle("row");
1077     fHistOROC->SetYTitle("pad");
1078     if(GetPedestals()) fHistOROC->SetZTitle("max ADC (baseline sub)");
1079     else               fHistOROC->SetZTitle("max ADC ");
1080     fHistOROC->SetTitle(titleOROC.Data());
1081     fHistOROC->SetMinimum(0.01);
1082     fHistOROC->Draw("COLZ");
1083     coroc->UseCurrentStyle();
1084     
1085     
1086     fHistOROCTime->SetXTitle("row"); fHistOROCTime->SetZTitle("peak time (fit) (timebins)"); fHistOROCTime->SetYTitle("pad"); fHistOROCTime->SetTitle(titleOROC.Data());
1087     fHistOROCRMS->SetXTitle("row");  fHistOROCRMS->SetZTitle("baseline rms (ADC)");          fHistOROCRMS->SetYTitle("pad");  fHistOROCRMS->SetTitle(titleOROC.Data());
1088     
1089     // SUM
1090     TString namesum=Form("ADC sum (bins: %i, %i)",GetRangeSumMin() ,GetRangeSumMax() );
1091     fHistIROCSUM->SetXTitle("row");
1092     fHistIROCSUM->SetZTitle(namesum.Data());
1093     fHistIROCSUM->SetYTitle("pad");
1094     fHistIROCSUM->SetTitle(titleIROC.Data());
1095     
1096     fHistOROCSUM->SetXTitle("row");
1097     fHistOROCSUM->SetZTitle(namesum);
1098     fHistOROCSUM->SetYTitle("pad");
1099     fHistOROCSUM->SetTitle(titleOROC.Data());
1100     
1101     // BASE
1102     TString namebase=Form("base mean (timbebin: %i, %i )",GetRangeBaseMin(),GetRangeBaseMax());
1103     fHistIROCBASE->SetXTitle("row");
1104     fHistIROCBASE->SetZTitle(namebase.Data());
1105     fHistIROCBASE->SetYTitle("pad");
1106     fHistIROCBASE->SetTitle(titleIROC.Data());
1107     
1108     fHistOROCBASE->SetXTitle("row");
1109     fHistOROCBASE->SetZTitle(namebase);
1110     fHistOROCBASE->SetYTitle("pad");
1111     fHistOROCBASE->SetTitle(titleOROC.Data());
1112     
1113     if(fHistIROCClone) fHistIROCClone->Delete();
1114     if(fHistOROCClone) fHistOROCClone->Delete();
1115     fHistIROCClone = (TH2F*)fHistIROC->Clone("fHistIROCClone");
1116     fHistOROCClone = (TH2F*)fHistOROC->Clone("fHistOROCClone");
1117     
1118       // Executables
1119     if(fExecPlaneMax==0)
1120     {
1121       TString carry1=Form(".x %s/TPC/AliTPCMonitorExec.C(1)",gSystem->Getenv("ALICE_ROOT"));
1122       ciroc->AddExec("pad",carry1.Data());
1123       coroc->AddExec("pad",carry1.Data());
1124       
1125       TString carry2=Form(".x %s/TPC/AliTPCMonitorExec.C(2)",gSystem->Getenv("ALICE_ROOT"));
1126       ciroc->AddExec("row",carry2.Data());
1127       coroc->AddExec("row",carry2.Data());
1128       fExecPlaneMax=1;
1129     }
1130     coroc->Update();
1131     ciroc->Update();
1132   }
1133   else if(histos==2)
1134   {
1135       // MAX ADC distribution  ____________________________________________
1136     TCanvas* cmax = 0;
1137     cmax = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("cmax");
1138     if(!cmax)  cmax = CreateCanvas("cmax");
1139     
1140     cmax->cd();
1141     fHistDistrMaxIROC->GetXaxis()->SetRangeUser(0.0,1000.0);
1142     fHistDistrMaxIROC->SetXTitle("max ADC (ADC)");
1143     fHistDistrMaxIROC->SetYTitle("counts");
1144     fHistDistrMaxIROC->SetTitle(titleMAX.Data());
1145     fHistDistrMaxIROC->Draw("");
1146     fHistDistrMaxOROC->SetLineColor(2);
1147     fHistDistrMaxOROC->Draw("same");
1148     
1149     if(fHistDistrMaxOROC->GetMaximum()> fHistDistrMaxIROC->GetMaximum())  fHistDistrMaxIROC->SetMaximum(fHistDistrMaxOROC->GetMaximum()*1.1);
1150     
1151     TLegend* legio = new TLegend(0.6,0.6,0.8,0.8);
1152     legio->SetFillColor(0);
1153     legio->AddEntry(fHistDistrMaxIROC,"IROC","l");
1154     legio->AddEntry(fHistDistrMaxOROC,"OROC","l");
1155     legio->Draw("same");
1156     
1157       // ADC sum distribution
1158     TCanvas* csum = 0;
1159     csum = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("csum");
1160     if(!csum)  csum = CreateCanvas("csum") ;
1161     csum->cd();
1162     
1163     fHistDistrSumIROC->SetXTitle("sum ADC (ADC)");
1164     fHistDistrSumIROC->SetYTitle("counts");
1165     fHistDistrSumIROC->SetTitle(titleSUM.Data());
1166     fHistDistrSumIROC->Draw("");
1167     fHistDistrSumOROC->SetLineColor(2);
1168     fHistDistrSumOROC->Draw("same");
1169     if(fHistDistrSumOROC->GetMaximum()> fHistDistrSumIROC->GetMaximum())  fHistDistrSumIROC->SetMaximum(fHistDistrSumOROC->GetMaximum()*1.1);
1170     legio->Draw("same");
1171     
1172       // BASELINE MEAN distribution
1173     TCanvas* cbasemean = 0;
1174     cbasemean = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("cbasemean");
1175     if(!cbasemean)  cbasemean = CreateCanvas("cbasemean");
1176     cbasemean->cd();
1177     
1178     fHistDistrBaseMeanIROC = fHistDistrBase2dIROC->ProjectionX("fHistDistrBaseMeanIROC");
1179     fHistDistrBaseMeanIROC->SetXTitle("base mean (ADC)");
1180     fHistDistrBaseMeanIROC->SetYTitle("counts");
1181     fHistDistrBaseMeanIROC->SetTitle(titleMEAN.Data());
1182     fHistDistrBaseMeanIROC->Draw("");
1183     
1184     fHistDistrBaseMeanOROC = fHistDistrBase2dOROC->ProjectionX("fHistDistrBaseMeanOROC");
1185     fHistDistrBaseMeanOROC->SetLineColor(2);
1186     fHistDistrBaseMeanOROC->Draw("same");
1187     if(fHistDistrBaseMeanOROC->GetMaximum()>fHistDistrBaseMeanIROC->GetMaximum())   fHistDistrBaseMeanIROC->SetMaximum(fHistDistrBaseMeanOROC->GetMaximum()*1.1);
1188     legio->Draw("same");
1189     
1190     TCanvas* cbaserms = 0;
1191     cbaserms = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("cbaserms");
1192     if(!cbaserms) cbaserms = CreateCanvas("cbaserms") ;
1193     cbaserms->cd();
1194     
1195       // BASELINE RMS distribution
1196     fHistDistrBaseRmsIROC = fHistDistrBase2dIROC->ProjectionY("fHistDistrBaseRmsIROC");
1197     fHistDistrBaseRmsIROC->SetXTitle("base rms (ADC)");
1198     fHistDistrBaseRmsIROC->SetYTitle("counts");
1199     fHistDistrBaseRmsIROC->SetTitle(titleRMS.Data());
1200     fHistDistrBaseRmsIROC->Draw("");
1201     
1202     fHistDistrBaseRmsOROC = fHistDistrBase2dOROC->ProjectionY("fHistDistrBaseRmsOROC");
1203     fHistDistrBaseRmsOROC->SetLineColor(2);
1204     fHistDistrBaseRmsOROC->Draw("same");
1205     if(fHistDistrBaseRmsOROC->GetMaximum()>fHistDistrBaseRmsIROC->GetMaximum())  fHistDistrBaseRmsIROC->SetMaximum(fHistDistrBaseRmsOROC->GetMaximum()*1.1);
1206     legio->Draw("same");
1207     
1208     cmax->Update();
1209     csum->Update();
1210     cbasemean->Update();
1211     cbaserms->Update();
1212   }
1213   else  if(histos==3)
1214   {
1215       // GLOBAL MAX ADC _________________________________
1216     if(GetProcNextEvent()==1)
1217     {
1218       TCanvas* cglobA =0;
1219       TCanvas* cglobC =0;
1220       
1221       if(!(cglobC=(TCanvas*)gROOT->GetListOfCanvases()->FindObject("SIDE C all"))) cglobC = CreateCanvas("SIDE C all");
1222       if(!(cglobA=(TCanvas*)gROOT->GetListOfCanvases()->FindObject("SIDE A all"))) cglobA = CreateCanvas("SIDE A all");
1223       
1224       TString globtitle1=Form("SIDE A Run %05i (EventID %i)",fRunId,fEventNumber);
1225       TString globtitle2=Form("SIDE C Run %05i (EventID %i)",fRunId,fEventNumber);
1226       
1227       fHistGlobalMaxA->SetTitle(globtitle1.Data());
1228       fHistGlobalMaxC->SetTitle(globtitle2.Data());
1229       fHistGlobalMaxA->SetXTitle("x/mm");
1230       fHistGlobalMaxA->SetYTitle("y/mm");
1231       fHistGlobalMaxC->SetXTitle("x/mm");
1232       fHistGlobalMaxC->SetYTitle("y/mm");
1233       
1234       if(GetPedestals()==0)     {             fHistGlobalMaxA->SetZTitle("max adc (not baseline sub)");   fHistGlobalMaxC->SetZTitle("max adc (not baseline sub)");  }
1235       else                          {         fHistGlobalMaxA->SetZTitle("max adc ");                     fHistGlobalMaxC->SetZTitle("max adc ");                          }
1236       
1237       fHistGlobalMaxA->SetMinimum(0.01);
1238       fHistGlobalMaxC->SetMinimum(0.01);
1239       
1240       cglobC->cd() ; fHistGlobalMaxC->Draw("COLZ");
1241       cglobA->cd() ; fHistGlobalMaxA->Draw("COLZ");
1242       
1243       TString nameom=Form(".x  %s/TPC/AliTPCMonitorExec.C(3)",gSystem->Getenv("ALICE_ROOT"));
1244       
1245       if(fExecGlob==0)
1246       {
1247         if(fVerb)cout << " set exec " << nameom.Data() << endl;
1248         cglobC->AddExec("glob",nameom.Data());
1249         cglobA->AddExec("glob",nameom.Data());
1250         fExecGlob = 1;
1251       }
1252       else
1253       {
1254         cglobC->DeleteExec("glob");
1255         cglobA->DeleteExec("glob");
1256         
1257         if(fVerb)  cout << " set exec " << nameom.Data() << endl;
1258         cglobC->AddExec("glob",nameom.Data());
1259         cglobA->AddExec("glob",nameom.Data());
1260         
1261       }
1262       cglobC->Update();
1263       cglobA->Update();
1264     }
1265     
1266   }
1267 }
1268
1269
1270
1271 //__________________________________________________________________
1272 void AliTPCMonitor::DrawRMSMap() 
1273 {
1274   // Draw 2Dim rms histos for IROC and OROC
1275   // and set executables for canvases
1276   
1277   TCanvas* crmsoroc =0;
1278   TCanvas* crmsiroc =0;
1279   if(!(crmsoroc = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("crmsoroc")))    crmsoroc    = CreateCanvas("crmsoroc");
1280   if(!(crmsiroc = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("crmsiroc")))    crmsiroc    = CreateCanvas("crmsiroc");
1281   
1282   crmsiroc->cd();  fHistIROCRMS->Draw("COLZ");
1283   crmsoroc->cd();  fHistOROCRMS->Draw("COLZ");
1284   
1285   TString carry1=Form(".x %s/TPC/AliTPCMonitorExec.C(1)",gSystem->Getenv("ALICE_ROOT"));
1286   TString carry2=Form(".x %s/TPC/AliTPCMonitorExec.C(2)",gSystem->Getenv("ALICE_ROOT"));
1287   
1288   if(fExecPadIrocRms==0)
1289   {
1290     crmsiroc->AddExec("pad",carry1.Data());
1291     crmsiroc->AddExec("row",carry2.Data());
1292     fExecPadIrocRms=1;
1293   }
1294   
1295   if(fExecPadOrocRms==0)
1296   {
1297     crmsoroc->AddExec("pad",carry1.Data());
1298     crmsoroc->AddExec("row",carry2.Data());
1299     fExecPadOrocRms=1;
1300   }
1301   
1302   crmsiroc->Update();
1303   crmsoroc->Update();
1304   
1305   DrawHists(2);
1306   
1307 }
1308
1309 //__________________________________________________________________
1310 void AliTPCMonitor::ExecPad() 
1311 {
1312   
1313   // Executable for Pad
1314   // Show time profile for channel the mouse is pointing at
1315   
1316   Int_t event = gPad->GetEvent();
1317   if (event != 51)   return;
1318   
1319   TObject *select = gPad->GetSelected();
1320   if(!select)    return;
1321   if(!select->InheritsFrom("TH2")) { return;  }
1322   gPad->GetCanvas()->FeedbackMode(kTRUE);
1323   
1324   // get position
1325   Int_t    px        = gPad->GetEventX();
1326   Int_t    py        = gPad->GetEventY();
1327   Float_t  upy       = gPad->AbsPixeltoY(py);
1328   Float_t  upx       = gPad->AbsPixeltoX(px);
1329   Float_t  y         = gPad->PadtoY(upy);
1330   Float_t  x         = gPad->PadtoX(upx);
1331   
1332   Int_t    setrange  = 0;
1333   
1334   TCanvas* cpad      = 0;
1335   //  Char_t   namehist[50];
1336   TString   projhist;
1337   TString   namesel;
1338   TString   namecanv;
1339   
1340   Int_t    xbinmin  = 0;
1341   Int_t    xbinmax  = 0;
1342   Float_t  ybinmin  = 0;
1343   Float_t  ybinmax  = 0;
1344   Int_t    rocid     = 0;
1345   // Check wich Canvas executed the event
1346   TH2S* fHistIndex=0;
1347   namesel=select->GetName();
1348   if(namesel=="fHistOROC" || namesel=="fHistOROCRMS" || namesel=="fHistOROCTime" )
1349   {
1350     rocid = 1;
1351     fPadUsedRoc =1;
1352     projhist=Form("ProjectionOROC");
1353     namecanv=Form("coroc_ch");
1354     fHistIndex = fHistOROCIndex;
1355   }
1356   if(namesel=="fHistIROC" || namesel=="fHistIROCRMS" || namesel=="fHistIROCTime" )
1357   {
1358     rocid = 0;
1359     fPadUsedRoc=0;
1360     projhist=Form("ProjectionIROC");
1361     namecanv=Form("ciroc_ch");
1362     fHistIndex = fHistIROCIndex;
1363   }
1364   
1365   // Check if Canvas already existed and get Ranges from former Prjection histogram
1366   if((cpad=(TCanvas*)gROOT->GetListOfCanvases()->FindObject(namecanv)))
1367   {
1368     cpad->cd();
1369     if(gROOT->Get(projhist))
1370     {
1371       setrange = 1;
1372       xbinmin = ((TH1D*)gROOT->Get(projhist))->GetXaxis()->GetFirst();
1373       xbinmax = ((TH1D*)gROOT->Get(projhist))->GetXaxis()->GetLast();
1374       ybinmin = ((TH1D*)gROOT->Get(projhist))->GetMinimum();
1375       ybinmax = ((TH1D*)gROOT->Get(projhist))->GetMaximum();
1376       delete gROOT->Get("legfit");
1377       delete gROOT->Get("fg");
1378     }
1379   }
1380   else
1381   {
1382     cpad = CreateCanvas(namecanv); cpad->cd();
1383   }
1384   
1385   // Get Bin
1386   if (!fHistIndex) return;
1387   Int_t testy = fHistIndex->GetYaxis()->FindBin(y);
1388   Int_t testx = fHistIndex->GetXaxis()->FindBin(x);
1389   Int_t binchannel = (Int_t)fHistIndex->GetCellContent(testx,testy);
1390   if(binchannel>30000 || binchannel<0) return;
1391   
1392   TH1D *hp=(TH1D*)gROOT->Get(projhist);
1393   if(!hp)  hp=new TH1D(projhist,projhist,GetTimeBins(),0,GetTimeBins());//delete gROOT->Get(projhist);
1394   // Get Projection
1395 //   TH1D *hp = (TH1D*)(((TH1D*)fHistChannelTime->ProjectionY("hp",binchannel,binchannel))->Clone(projhist));
1396 //   TH1D *hp = fHistChannelTime->ProjectionY(projhist,binchannel,binchannel);
1397 //   hp->Reset();
1398   Int_t nbinsx=fHistChannelTime->GetNbinsX();
1399   for (Int_t itb=0;itb<GetTimeBins();++itb){
1400     hp->GetArray()[itb]=fHistChannelTime->GetArray()[binchannel+itb*(nbinsx+2)];
1401   }
1402 //   printf("hi\n");
1403 //   return;
1404   
1405   // Make title and Pave for channel Info
1406   Int_t npadRow , npad  , nhw , nmax , hwadd;
1407   
1408   hwadd   = (Int_t)fHistChannelTime->GetCellContent(binchannel,0);
1409   fPadUsedHwAddr = hwadd;
1410   
1411   if(rocid==0)npadRow = fMapHand->GetPadRow(hwadd);
1412   else        npadRow = fMapHand->GetPadRow(hwadd)-63;
1413   npad                = fMapHand->GetPad(hwadd);
1414   nhw                 = hwadd;
1415   nmax                = (Int_t)hp->GetMaximum();
1416   
1417   
1418   TPaveText*  legstat = new TPaveText(0.18,0.65,0.3,0.8,"NDC");
1419   
1420   Int_t   connector   =  fMapHand->GetFECconnector(hwadd);
1421   Int_t   fecnr       =  fMapHand->GetFECfromHw(hwadd);
1422   Int_t   fecch       =  fMapHand->GetFECchannel(hwadd);
1423   Int_t   altrochip   =  fMapHand->GetAltro(hwadd);
1424   Int_t   altrochannel=  (fMapHand->GetAltroChannel(hwadd))%16;
1425   Int_t   fecloc      =  fMapHand->U2fGetFECinRCU(fecnr) ;
1426   Int_t   feclocbran  =  fMapHand->U2fGetFECinBranch(fecnr);
1427   Int_t   branch      =  fMapHand->U2fGetBranch(fecnr);
1428   
1429   
1430   Short_t fecget      = (hwadd & fgkHwMaskFEC)   >> 7;
1431   Short_t branchget   = (hwadd & fgkHwMaskBranch)>> 11;
1432   
1433   legstat->AddText(Form("Branch (map) \t %i (%i) \n",branchget,branch));
1434   legstat->AddText(Form("Fec in patch \t %i \n",fecloc));
1435   legstat->AddText(Form("Fec in branch (map)\t %i (%i)\n",fecget,feclocbran));
1436   legstat->AddText(Form("Connector  \t %i \n",connector));
1437   legstat->AddText(Form("Fec No.   \t %i \n",fecnr));
1438   legstat->AddText(Form("Fec chan  \t %i \n",fecch));
1439   legstat->AddText(Form("Altro chip\t %i \n",altrochip));
1440   legstat->AddText(Form("Altro chan\t %i \n",altrochannel));
1441   
1442   TString title=Form("Row=%d Pad=%d Hw =%d maxADC =%d count =%d",npadRow,npad,nhw,nmax,binchannel);
1443   
1444 //   hp->SetName(projhist);
1445   hp->SetTitleSize(0.04);
1446   hp->SetTitle(title.Data());
1447   hp->SetYTitle("ADC");
1448   hp->SetXTitle("Timebin");
1449   hp->GetXaxis()->SetTitleColor(1);
1450   
1451   if(setrange)
1452   {
1453     hp->GetXaxis()->SetRange(xbinmin,xbinmax);
1454     hp->SetMinimum(ybinmin);
1455     hp->SetMaximum(ybinmax);
1456   }
1457   else
1458   {
1459     hp->SetMinimum(0.0);
1460     hp->SetMaximum(1000.0);
1461   }
1462   
1463   cpad->cd();
1464   hp->Draw();
1465   
1466   // Make Fit to peak
1467   if(GetPedestals() && fDisableFit==0)
1468   {
1469     Int_t maxx  =    (Int_t)fHistAddrMaxAdcX->GetBinContent(hwadd);
1470     Float_t max  =  (Float_t)fHistAddrMaxAdc->GetBinContent(hwadd);
1471     Float_t base =  (Float_t)fHistAddrBaseMean->GetBinContent(hwadd);
1472     if(base!=0)
1473     {
1474       if( ((max+base)/base)>1.2)
1475       {
1476         TF1* fg = new TF1("fg",AliTPCMonitor::Gamma4,maxx-5,maxx+5,4);
1477         fg->SetParName(0,"Normalisation");
1478         fg->SetParName(1,"Minimum");
1479         fg->SetParName(2,"Width");
1480         fg->SetParName(3,"Base");
1481         fg->SetParameter(0,max);
1482         fg->SetParameter(1,maxx-2);
1483         fg->SetParameter(2,1.5);
1484         fg->FixParameter(3,0);
1485         fg->SetLineColor(4);
1486         fg->SetLineWidth(1);
1487         hp->Fit("fg","RQ");
1488         
1489         TLegend* legfit = new TLegend(0.6,0.7,0.7,0.8);
1490         legfit->AddEntry("fg","#Gamma 4 fit","l");
1491         legfit->SetFillColor(0);
1492         legfit->SetName("legfit");
1493         legfit->Draw("same");
1494       }
1495     }
1496   }
1497   legstat->SetFillColor(0);
1498   legstat->Draw("same");
1499   cpad->Update();
1500   return;
1501 }
1502
1503 //__________________________________________________________________
1504 void AliTPCMonitor::ExecRow() 
1505 {
1506   
1507   // Executable for Pad
1508   // Show profile of max adc over given pad row
1509   // and 2dim histo  adc(pad-in-row,time bin)
1510   
1511   Int_t event = gPad->GetEvent();
1512   if (event != 61)    return;
1513   gPad->cd();
1514   TObject *select = gPad->GetSelected();
1515   if(!select)    return;
1516   if(!select->InheritsFrom("TH2")) {   return;  }
1517   
1518   Int_t rocid = 0;
1519   
1520   const Char_t *rowhist="hrowtime";
1521   const Char_t *rowhistxmax="hxmax";
1522   const Char_t *rowhistmax="hrowmax";
1523   
1524   // get position
1525   Int_t   px  = gPad->GetEventX();
1526   Int_t   py  = gPad->GetEventY();
1527   Float_t upy = gPad->AbsPixeltoY(py);
1528   Float_t upx = gPad->AbsPixeltoX(px);
1529   Float_t y   = gPad->PadtoY(upy);
1530   Float_t x   = gPad->PadtoX(upx);
1531   
1532   TCanvas*crowtime   = 0;
1533   TCanvas*crowmax    = 0;
1534   TCanvas*cxmax      = 0;
1535   
1536   TH2S*  fHistIndex  = 0;
1537   
1538   // ranges from already existing histos
1539   Int_t    rowtimexmin = 0;
1540   Int_t    rowtimexmax = 0;
1541   Int_t    rowtimeymin = 0;
1542   Int_t    rowtimeymax = 0;
1543   Float_t  rowtimezmin = 0;
1544   Float_t  rowtimezmax = 0;
1545   
1546   Int_t    profrowxmin = 0;
1547   Int_t    profrowxmax = 0;
1548   Double_t profrowymin = 0;
1549   Double_t profrowymax = 0;
1550   
1551   Int_t    profxxmin   = 0;
1552   Int_t    profxxmax   = 0;
1553   Double_t profxymin   = 0;
1554   Double_t profxymax   = 0;
1555   
1556   
1557   Int_t    setrange      = 0;
1558   
1559   TString name=select->GetName();
1560   if(     name=="fHistIROC" || name=="fHistIROCRMS" ) { fHistIndex = fHistIROCIndex;     rocid =1;   }
1561   else if(name=="fHistOROC" || name=="fHistOROCRMS" ) { fHistIndex = fHistOROCIndex;     rocid =2;   }
1562   else  { cout << " not implemented for this histo " << endl; return; }
1563   
1564   gPad->GetCanvas()->FeedbackMode(kTRUE);
1565   
1566   
1567   
1568   // check if canvases exist //
1569   crowtime  = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("crowtime");
1570   crowmax   = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("crowmax");
1571   cxmax     = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("cxmax");
1572   
1573   if(!crowtime)   crowtime   = CreateCanvas("crowtime") ;
1574   if(!crowmax)    crowmax    = CreateCanvas("crowmax")  ;
1575   if(!cxmax  )    cxmax      = CreateCanvas("cxmax")    ;
1576   
1577   // check ranges of already existing histos
1578   if(gROOT->Get(rowhist))
1579   {
1580     rowtimexmin  = ((TH2F*)gROOT->Get(rowhist))->GetXaxis()->GetFirst();
1581     rowtimexmax  = ((TH2F*)gROOT->Get(rowhist))->GetXaxis()->GetLast();
1582     rowtimeymin  = ((TH2F*)gROOT->Get(rowhist))->GetYaxis()->GetFirst();
1583     rowtimeymax  = ((TH2F*)gROOT->Get(rowhist))->GetYaxis()->GetLast();
1584     rowtimezmin  = ((TH2F*)gROOT->Get(rowhist))->GetMinimum();
1585     rowtimezmax  = ((TH2F*)gROOT->Get(rowhist))->GetMaximum();
1586     
1587     profrowxmin  = ((TH1F*)gROOT->Get(rowhistmax))->GetXaxis()->GetFirst();
1588     profrowxmax  = ((TH1F*)gROOT->Get(rowhistmax))->GetXaxis()->GetLast();
1589     profrowymin  = ((TH1F*)gROOT->Get(rowhistmax))->GetMinimum();
1590     profrowymax  = ((TH1F*)gROOT->Get(rowhistmax))->GetMaximum();
1591     
1592     profxxmin    = ((TH1F*)gROOT->Get(rowhistxmax))->GetXaxis()->GetFirst();
1593     profxxmax    = ((TH1F*)gROOT->Get(rowhistxmax))->GetXaxis()->GetLast();
1594     profxymin    = ((TH1F*)gROOT->Get(rowhistxmax))->GetMinimum();
1595     profxymax    = ((TH1F*)gROOT->Get(rowhistxmax))->GetMaximum();
1596     
1597     setrange =1;
1598     
1599     delete gROOT->Get(rowhist);
1600     delete gROOT->Get(rowhistmax);
1601     delete gROOT->Get("hxmax");
1602     delete gROOT->Get("legrow");
1603   }
1604   
1605   // get channel for xy bin -> getRow -> getNrows -> getHw for each Pad in Row -> get channel for each hw -> make proj
1606   Int_t testy      = fHistIndex->GetYaxis()->FindBin(y);
1607   Int_t testx      = fHistIndex->GetXaxis()->FindBin(x);
1608   Int_t binchannel = (Int_t)fHistIndex->GetCellContent(testx,testy);
1609   
1610   if(binchannel>30000)    return;
1611   if(binchannel<=0 ) { crowtime->Update() ;    crowmax->Update() ;    return ;  }
1612   
1613   // get hwaddress
1614   Int_t hwadd     = (Int_t)fHistChannelTime->GetCellContent(binchannel,0);
1615   Int_t row       = fMapHand->GetPadRow(hwadd);
1616   Int_t pad       = fMapHand->GetPad(hwadd)   ;
1617   Int_t numofpads =  fMapHand->GetNumofPads(row);
1618   
1619   // create histos
1620   TH2F *hrowtime = new TH2F(rowhist     , ""  ,numofpads,0,numofpads,GetTimeBins(),0.0,GetTimeBins());
1621   TH1F *hrowmax  = new TH1F(rowhistmax , ""  ,numofpads,0,numofpads);
1622   TH1F *hxmax    = new TH1F(rowhistxmax, ""  ,159,0,159      );
1623   
1624   // Row profile ///////////
1625   if(fVerb) cout << " Number of pads " << numofpads << endl;
1626   for(Int_t padnr = 0; padnr<numofpads;padnr++)
1627   {
1628     Int_t addrinrow = fMapHand->GetPadAddInRow(row,padnr );
1629     Int_t channel   = (Int_t)fHistAddrMapIndex->GetBinContent(addrinrow);
1630     if(channel==-1) continue;
1631     
1632     hrowmax->SetBinContent(padnr+1,fHistAddrMaxAdc->GetBinContent(addrinrow));
1633     TH1D *hp = fHistChannelTime->ProjectionY("hp",channel,channel);
1634     for(Int_t time = 0;time<GetTimeBins();time++) {
1635       
1636       Float_t val = hp->GetBinContent(time);
1637       hrowtime->SetCellContent(padnr+1,time+1,val);
1638     }
1639   }
1640   
1641   // X profile  /////////////
1642   Double_t xval  = 0.0;
1643   Double_t yval  = 0.0;
1644   GetXY(xval,yval,numofpads,row,pad);
1645   
1646   Int_t padnr = 0;
1647   Int_t hw    = 0;
1648   for(Int_t nrow = 0; nrow<159; nrow++)
1649   {
1650     padnr = GetPadAtX(xval,nrow);
1651     if(padnr>=0)
1652     {
1653       hw = fMapHand->GetPadAddInRow(nrow,padnr);
1654       if(fPadMapHw[hw]==-1){ continue                                                      ; }
1655       else                { hxmax->SetBinContent(nrow+1,fHistAddrMaxAdc->GetBinContent(hw))   ; }
1656     }
1657   }
1658   
1659   cxmax->cd();
1660   hxmax->SetTitle(Form("max adc in pads at x=%5.1f mm",xval));
1661   hxmax->SetXTitle("row");
1662   if(!GetPedestals()) hxmax->SetYTitle("max adc (baseline sub.)");
1663   else                hxmax->SetYTitle("max adc ");
1664   hxmax->SetMinimum(0.01);
1665   hxmax->Draw("l");
1666   
1667   if(setrange)
1668   {
1669     hxmax->GetXaxis()->SetRange(profxxmin,profxxmax);
1670     hxmax->SetMinimum(profxymin);
1671     hxmax->SetMaximum(profxymax);
1672   }
1673   
1674   cxmax->Update();
1675   
1676   crowtime->cd();
1677   TString title;
1678   TString titlemax;
1679   if(rocid==1) {
1680     title.Form("%s Row=%d",((TH2*)select)->GetTitle(),row)   ;
1681     titlemax.Form("IROC  max/sum Row=%d",row   );
1682   }  else  {
1683     title.Form("%s Row=%d",((TH2*)select)->GetTitle(),row-63);
1684     titlemax.Form("OROC  max/sum Row=%d",row-63);
1685   }
1686   
1687   if(fVerb) cout << " set name " << endl;
1688   
1689   
1690   // row vs time
1691   crowtime->cd();
1692   hrowtime->SetTitleSize(0.04);
1693   hrowtime->SetTitle(title.Data());
1694   hrowtime->SetYTitle("timbin");
1695   hrowtime->SetXTitle("pad in row");
1696   hrowtime->SetZTitle("signal (ADC)");
1697   
1698   hrowtime->GetXaxis()->SetTitleColor(1);
1699   hrowtime->SetMaximum(1000.0);
1700   hrowtime->SetMinimum(0.0);
1701   
1702   if(setrange)
1703   {
1704     hrowtime->GetXaxis()->SetRange(rowtimexmin,rowtimexmax);
1705     hrowtime->GetYaxis()->SetRange(rowtimeymin,rowtimeymax);
1706     hrowtime->SetMinimum(rowtimezmin);
1707     hrowtime->SetMaximum(rowtimezmax);
1708   }
1709   
1710   hrowtime->Draw("COLZ");
1711   crowtime->UseCurrentStyle();
1712   crowtime->Update();
1713   
1714   // max and sum /////////////////////////
1715   crowmax->cd();
1716   if(setrange) {
1717     hrowmax->GetXaxis()->SetRange(profrowxmin,profrowxmax);
1718     hrowmax->SetMinimum(profrowymin);
1719     hrowmax->SetMaximum(profrowymax);
1720   }
1721   hrowmax->SetTitleSize(0.04);
1722   hrowmax->SetTitle(title.Data());
1723   hrowmax->SetYTitle("max adc");
1724   hrowmax->SetXTitle("pad in row");
1725   hrowmax->GetXaxis()->SetTitleColor(1);
1726   
1727   hrowmax->SetLineColor(2);
1728   hrowmax->Draw("l");
1729   crowmax->Update();
1730   
1731   return;
1732 }
1733
1734 //__________________________________________________________________
1735 void AliTPCMonitor::Write10bitChannel()
1736 {
1737   
1738   // Write 10 bit words form histogram for active(last pointed)  channel
1739   
1740   if(fPadUsedHwAddr==-1){ AliWarning(" No active pad "); return ;}
1741   
1742   Int_t  pad     = (Int_t)fMapHand->GetPad(   fPadUsedHwAddr);
1743   Int_t  row     = (Int_t)fMapHand->GetPadRow(fPadUsedHwAddr);
1744   Int_t  channel = (Int_t)fPadMapHw[fPadUsedHwAddr];
1745   
1746   TString filenameroot;
1747   TString filenamedat;
1748   TString projhist;
1749   
1750   if(fPadUsedRoc==1) { projhist.Form("ProjectionOROC"); }
1751   if(fPadUsedRoc==0) { projhist.Form("ProjectionIROC"); }
1752   
1753   filenamedat.Form("Channel_Run%05i_EventID_%i_Pad_%i_Row_%i.dat"      ,fRunId,fEventNumber,pad,row);
1754   filenameroot.Form("Channel_Run%05i_EventID_%i_Pad_%i_Row_%i.root"     ,fRunId,fEventNumber,pad,row);
1755   
1756   TH1D* hpr = 0;
1757   if((hpr=(TH1D*)gROOT->Get(projhist)))
1758   {
1759       // root histo
1760     TFile f(filenameroot.Data(),"recreate");
1761     hpr->Write();
1762     f.Close();
1763     
1764       // raw singal
1765     ofstream datout(filenamedat.Data(),ios::out);
1766     datout <<"Timebin \t ADC value " << endl;
1767     for(Int_t i = 1; i <GetTimeBins(); i++)
1768     {
1769       datout << i << " \t \t " << fPad[channel][i] << endl;
1770     }
1771     datout.close();
1772   }
1773   else
1774   {
1775     AliWarning("No projection histo found ");
1776   }
1777 }
1778
1779 //__________________________________________________________________
1780 void AliTPCMonitor::ExecTransform() 
1781 {
1782   
1783   // Make Fast Fourier Transformation for active pad
1784   // fft is only performed for a data sample of size 2^n
1785   // reduce window according to largest  power of 2 which is smaller than the viewing  range
1786   
1787   TString namecanv;
1788   TString namecanv2;
1789   TString projhist;
1790   TString namehtrimag;
1791   TString namehtrreal;
1792   TString namehtrmag;
1793   
1794   if(fPadUsedRoc==1) {    namecanv="coroc_ch_trans"; namecanv2="coroc_ch_trans2";  projhist="ProjectionOROC";  }
1795   if(fPadUsedRoc==0) {    namecanv="ciroc_ch_trans"; namecanv2="ciroc_ch_trans2";  projhist="ProjectionIROC";  }
1796   
1797   TH1D*  hproj = 0;
1798   
1799   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 ;}
1800   else      hproj = (TH1D*)gROOT->Get(projhist.Data()) ;
1801   
1802   
1803   if(fPadUsedRoc==1) {  namehtrimag="htransimagfreq_oroc";    namehtrreal="htransrealfreq_oroc"; namehtrmag="htransmagfreq_oroc";  }
1804   else               {  namehtrimag="htransimagfreq_iroc";    namehtrreal="htransrealfreq_iroc"; namehtrmag="htransmagfreq_iroc";  }
1805   
1806   if( gROOT->Get(namehtrimag.Data()))  delete  gROOT->Get(namehtrimag.Data());
1807   if( gROOT->Get(namehtrreal.Data()))  delete  gROOT->Get(namehtrreal.Data());
1808   if( gROOT->Get(namehtrmag.Data()))  delete  gROOT->Get(namehtrmag.Data());
1809   
1810   TCanvas *ctrans = 0;
1811   if(!(ctrans = (TCanvas*)gROOT->GetListOfCanvases()->FindObject(namecanv.Data())))
1812   {
1813     ctrans = CreateCanvas(namecanv.Data());
1814     ctrans->Divide(1,2);
1815   }
1816   TCanvas *ctrans2 = 0;
1817   if(!(ctrans2 = (TCanvas*)gROOT->GetListOfCanvases()->FindObject(namecanv2.Data())))
1818   {
1819     ctrans2 = CreateCanvas(namecanv2.Data());
1820 //      ctrans2->Divide(1,2);
1821   }
1822   
1823   Int_t binfirst  =  hproj->GetXaxis()->GetFirst();
1824   Int_t binlast   =  hproj->GetXaxis()->GetLast();
1825   Int_t bins       =  binlast -binfirst +1;
1826   
1827   Int_t power = 0;
1828   for(Int_t pot = 0; pot<=10 ; pot++)
1829   {
1830     Int_t comp =  (Int_t)TMath::Power(2,pot);
1831     if(bins>=comp)power = pot;
1832   }
1833   
1834   bins = (Int_t)TMath::Power(2,power);
1835   
1836   // sampling frequency ;
1837   Double_t  deltat = 1.0/(Float_t)GetSamplingFrequency();
1838   
1839   // output histo
1840   TH1D* htransrealfreq = new TH1D(namehtrreal.Data(),namehtrreal.Data(),10000,-1/(2*deltat),1/(2*deltat));
1841   TH1D* htransimagfreq = new TH1D(namehtrimag.Data(),namehtrimag.Data(),10000,-1/(2*deltat),1/(2*deltat));
1842   TH1D* htransmag      = new TH1D(namehtrmag.Data(),namehtrmag.Data(),10000,-1/(2*deltat),1/(2*deltat));
1843   
1844   TString titlereal;
1845   TString titleimag;
1846   TString titlemag;
1847   if(fPadUsedRoc==1) {    titlereal="OROC DFT real part";  titleimag="OROC DFT imag part";  titlemag="OROC DFT magnitude";  }
1848   else {                  titlereal="IROC DFT real part";  titleimag="IROC DFT imag part";  titlemag="IROC DFT magnitude";  }
1849   
1850   htransrealfreq->SetTitle(titlereal.Data());  htransrealfreq->SetXTitle("f/hz");  htransrealfreq->SetYTitle("z_{real}(f)");
1851   htransimagfreq->SetTitle(titleimag.Data());  htransimagfreq->SetXTitle("f/hz");  htransimagfreq->SetYTitle("z_{imag}(f)");
1852   htransmag->SetTitle(titlemag.Data());  htransmag->SetXTitle("f/hz");  htransmag->SetYTitle("mag(f)");
1853   
1854   // create complex packed data array
1855   const Int_t kdatasiz = 2*bins;
1856   Double_t*  data = new Double_t[kdatasiz];
1857   for(Int_t i=0;i<2*bins;i++)  { data[i]   =  0.0;}
1858   for(Int_t i=0;i<bins;i++)    { data[2*i] = (Double_t)hproj->GetBinContent(binfirst+i); }
1859   
1860   // make fourier transformation
1861   AliTPCMonitorFFT* four = new AliTPCMonitorFFT();
1862   four->ComplexRadix2ForwardWrap(data,1,bins);
1863   
1864   // write output  and fill histos forward
1865   Double_t freq =  0.0;
1866   for(Int_t i=0;i<2*bins;i++)
1867   {
1868     if(i<bins)
1869     {
1870       if(i<(bins/2))  { freq = i/(bins*deltat)            ; }
1871       else            { freq = -1*((bins-i)/(bins*deltat)); }
1872       htransrealfreq->Fill( freq,data[2*i]  );
1873       htransimagfreq->Fill( freq,data[2*i+1]);
1874       htransmag->Fill( freq, TMath::Sqrt(data[2*i]*data[2*i]+data[2*i+1]*data[2*i+1]) );
1875     }
1876   }
1877   
1878   ctrans->cd(1);
1879   htransrealfreq->Draw();
1880   ctrans->cd(2);
1881   htransimagfreq->Draw();
1882   ctrans->Update();
1883   ctrans2->cd();
1884   htransmag->Draw();
1885   ctrans2->Update();
1886   delete four;
1887   delete [] data;
1888 }
1889
1890 //__________________________________________________________________
1891 void AliTPCMonitor::ShowSel(Int_t* compval)               
1892 {
1893   
1894   // Show only selected components
1895   // First restore original histogram from clone
1896   // Than remove all not matching pads form histos
1897   
1898   Int_t   connector   =  0;
1899   Int_t   fecnr       =  0;
1900   Int_t   altrochip   =  0;
1901   Int_t   feclocbran  =  0;
1902   Int_t   branch      =  0;
1903   Short_t rcuget      =  0;
1904   Int_t   emptyI      =  1;
1905   Int_t   index       = -1;
1906   Int_t   hwadd       =  0;
1907   
1908   Float_t maxiroc     =  fHistIROCClone->GetMaximum();
1909   Float_t maxoroc     =  fHistOROCClone->GetMaximum();
1910   
1911   
1912   //  restore original histos
1913   for(Int_t row = 0; row<fkNRowsIroc;  row++)
1914   {
1915     for(Int_t pad = 0; pad<fkNPadsIroc;  pad++)
1916     {
1917       index = (Int_t)fHistIROCIndex->GetCellContent(row+1,pad+1);
1918       if(index==-1)continue;
1919       else  fHistIROC->SetCellContent(row+1,pad+1,fHistIROCClone->GetCellContent(row+1,pad+1));
1920     }
1921   }
1922   for(Int_t row = 0; row<fkNRowsOroc;  row++)
1923   {
1924     for(Int_t pad = 0; pad<fkNPadsOroc;  pad++)
1925     {
1926       index = (Int_t)fHistOROCIndex->GetCellContent(row+1,pad+1);
1927       if(index==-1)continue;
1928       else    fHistOROC->SetCellContent(row+1,pad+1,fHistOROCClone->GetCellContent(row+1,pad+1));
1929     }
1930   }
1931   
1932   
1933   // remove not matching entries from fHistIROC/fHistOROC
1934   
1935   TH2F* fHist       =0;
1936   TH2S* fHistIndex  =0;
1937   Int_t npads       =0;
1938   Int_t subrows     =0;
1939   
1940   for(Int_t row = 0; row< (fkNRowsIroc + fkNRowsOroc);  row++)
1941   {
1942     if(row<fkNRowsIroc) {  fHist=fHistIROC ; fHistIndex = fHistIROCIndex; npads = fkNPadsIroc; subrows =0         ;}
1943     else                {  fHist=fHistOROC ; fHistIndex = fHistOROCIndex; npads = fkNPadsOroc; subrows =fkNRowsIroc;}
1944     
1945     for(Int_t pad = 0; pad<npads;  pad++)
1946     {
1947       index    = (Int_t)fHistIndex->GetCellContent(row -subrows +1,pad+1);
1948       if(index==-1)  continue ;
1949       hwadd    = (Int_t)fHistChannelTime->GetCellContent(index,0);
1950       
1951     // global fecnr
1952       fecnr     =  fMapHand->GetFECfromHw(hwadd);
1953       if(compval[0]!=-1 && fecnr!=compval[0])      {      fHist->SetCellContent(row-subrows+1,pad+1,0);           continue;     }
1954       
1955     // rcu
1956       rcuget      = (hwadd & fgkHwMaskRCU)>> 12;
1957       if(compval[1]!=-1 && rcuget!=compval[1])     {      fHist->SetCellContent(row-subrows+1,pad+1,0);           continue;     }
1958       
1959     // branch
1960       branch    =  fMapHand->U2fGetBranch(fecnr) ;
1961       if(compval[2]!=-1 && branch!=compval[2])     {      fHist->SetCellContent(row-subrows+1,pad+1,0);           continue;     }
1962       
1963     // local fec
1964       feclocbran=   fMapHand->U2fGetFECinBranch(fecnr) ;
1965       if(compval[3]!=-1 && feclocbran!=compval[3]) {      fHist->SetCellContent(row-subrows+1,pad+1,0);           continue;     }
1966       
1967     // connector
1968       connector =  fMapHand->GetFECconnector(hwadd);
1969       if(compval[4]!=-1 && connector!=compval[4])  {      fHist->SetCellContent(row-subrows+1,pad+1,0);           continue;     }
1970       
1971     // Altro chip
1972       altrochip     =  fMapHand->GetAltro(hwadd);
1973       if(compval[5]!=-1 && altrochip!=compval[5])      {          fHist->SetCellContent(row-subrows+1,pad+1,0);           continue;     }
1974       emptyI =0;
1975     }
1976   }
1977   
1978   TCanvas* c1 =0;
1979   TCanvas* c2 =0;
1980   if(gROOT->GetListOfCanvases()->FindObject("ciroc"))
1981   {
1982     c1 = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("ciroc");
1983     c1->cd() ;
1984     fHistIROC->Draw("COLZ");
1985     fHistIROC->SetMaximum(maxiroc);
1986     fHistIROC->SetMinimum(0.0);
1987     c1->Update();
1988   }
1989   if(gROOT->GetListOfCanvases()->FindObject("coroc"))
1990   {
1991     c2 =  (TCanvas*)gROOT->GetListOfCanvases()->FindObject("coroc");
1992     c2->cd() ;
1993     fHistOROC->Draw("COLZ");
1994     fHistOROC->SetMaximum(maxoroc);
1995     fHistOROC->SetMinimum(0.0);
1996     c2->Update();
1997   }
1998   return ;
1999 }
2000
2001 //__________________________________________________________________
2002 void AliTPCMonitor::ResizeCanv() 
2003 {
2004   // Resize canvases and delete some of them
2005   
2006   TString carry1=Form(".x %s/TPC/AliTPCMonitorExec.C(1)",gSystem->Getenv("ALICE_ROOT"));
2007   TString carry3=Form(".x %s/TPC/AliTPCMonitorExec.C(2)",gSystem->Getenv("ALICE_ROOT"));
2008   if(fVerb) cout <<  " canv 1 " << endl;
2009   
2010   if(gROOT->GetListOfCanvases()->FindObject(        "coroc_ch")) {  delete gROOT->GetListOfCanvases()->FindObject("coroc_ch") ; }
2011   if(gROOT->GetListOfCanvases()->FindObject(        "ciroc_ch")) {  delete gROOT->GetListOfCanvases()->FindObject("ciroc_ch") ; }
2012   
2013   // for 2dim plots delete create and draw again
2014   if(gROOT->GetListOfCanvases()->FindObject("ciroc"))
2015   {
2016     delete  gROOT->GetListOfCanvases()->FindObject("ciroc");
2017     TCanvas* ciroc = CreateCanvas("ciroc");
2018     ciroc->cd();
2019     fHistIROC->Draw("COLZ");
2020     ciroc->AddExec("pad",carry1.Data());
2021     ciroc->AddExec("row",carry3.Data());
2022     fExecPlaneMax=1;
2023     ciroc->Update();
2024   }
2025   // for 2dim plots delete create and draw again
2026   if(gROOT->GetListOfCanvases()->FindObject("coroc"))
2027   {
2028     delete gROOT->GetListOfCanvases()->FindObject("coroc");
2029     TCanvas* coroc = CreateCanvas("coroc");
2030     coroc->cd();
2031     fHistOROC->Draw("COLZ");
2032     
2033     coroc->AddExec("pad",carry1.Data());
2034     coroc->AddExec("row",carry3.Data());
2035     coroc->Update();
2036     fExecPlaneMax=1;
2037   }
2038   
2039   if(gROOT->GetListOfCanvases()->FindObject(       "cbasemean")) {    delete gROOT->GetListOfCanvases()->FindObject("cbasemean"); }
2040   if(gROOT->GetListOfCanvases()->FindObject(           "cbase")) {    delete gROOT->GetListOfCanvases()->FindObject("cbase");}
2041   if(gROOT->GetListOfCanvases()->FindObject(        "cbaserms")) {    delete gROOT->GetListOfCanvases()->FindObject("cbaserms");  }
2042   if(gROOT->GetListOfCanvases()->FindObject(            "cmax")) {    delete gROOT->GetListOfCanvases()->FindObject("cmax");      }
2043   if(gROOT->GetListOfCanvases()->FindObject(            "csum")) {    delete gROOT->GetListOfCanvases()->FindObject("csum");      }
2044   if(gROOT->GetListOfCanvases()->FindObject(  "ciroc_ch_trans")) {    delete gROOT->GetListOfCanvases()->FindObject("ciroc_ch_trans");}
2045   if(gROOT->GetListOfCanvases()->FindObject(  "coroc_ch_trans")) {    delete gROOT->GetListOfCanvases()->FindObject("coroc_ch_trans");}
2046   if(gROOT->GetListOfCanvases()->FindObject(       "crowtime")) {    delete gROOT->GetListOfCanvases()->FindObject("crowtime"); }
2047   if(gROOT->GetListOfCanvases()->FindObject(        "crowmax")) {    delete gROOT->GetListOfCanvases()->FindObject("crowmax");  }
2048   if(gROOT->GetListOfCanvases()->FindObject(          "cxmax")) {    delete gROOT->GetListOfCanvases()->FindObject("cxmax");    }
2049   if(gROOT->GetListOfCanvases()->FindObject(        "crmsoroc")) {    delete gROOT->GetListOfCanvases()->FindObject("crmsoroc");         fExecPadOrocRms = 0;   }
2050   if(gROOT->GetListOfCanvases()->FindObject(        "crmsiroc")) {    delete gROOT->GetListOfCanvases()->FindObject("crmsiroc");         fExecPadIrocRms = 0;   }
2051   if(gROOT->GetListOfCanvases()->FindObject(        "crowmax")) {    delete gROOT->GetListOfCanvases()->FindObject("crowmax");  }
2052   if(gROOT->GetListOfCanvases()->FindObject(        "crowmax")) {    delete gROOT->GetListOfCanvases()->FindObject("crowmax");  }
2053   
2054 }
2055
2056
2057
2058
2059 //__________________________________________________________________
2060 Int_t AliTPCMonitor::ExecProcess() 
2061 {
2062   // Executable for global Histogram
2063   // Will be called from /TPC/AliTPCMonitorExec.C(3)
2064   // Call ProcessEvent for same event and sector pointed at
2065   
2066   Int_t side   = 0;
2067   Int_t sector = 0;
2068   
2069   Int_t event = gPad->GetEvent();
2070   if(event != 61)  return -1;
2071   
2072   TObject *select = gPad->GetSelected();
2073   TString name=select->GetName();
2074   if(!select)  return -1;
2075   if(!select->InheritsFrom("TH2")) {gPad->SetUniqueID(0);    return -1;  }
2076   if(       name=="hglobal"  || name=="SIDE A"  ) side = 0;
2077   else  if( name=="hglobal2" || name=="SIDE C"  ) side = 1;
2078   
2079   // get position
2080   Int_t   px    = gPad->GetEventX();
2081   Int_t   py    = gPad->GetEventY();
2082   Float_t upy   = gPad->AbsPixeltoY(py);
2083   Float_t upx   = gPad->AbsPixeltoX(px);
2084   Float_t y     = gPad->PadtoY(upy);
2085   Float_t x     = gPad->PadtoX(upx);
2086   
2087   Int_t testy = ((TH2*)select)->GetYaxis()->FindBin(y);
2088   Int_t testx = ((TH2*)select)->GetXaxis()->FindBin(x);
2089   if(((TH2*)select)->GetCellContent(testx,testy)==0) return -1 ;
2090   
2091   Float_t alpha = 0.0;
2092   if(x>0.0 && y > 0.0)    alpha = TMath::Abs(TMath::ATan(TMath::Abs(x/y)));
2093   if(x>0.0 && y < 0.0)    alpha = TMath::Abs(TMath::ATan(TMath::Abs(y/x)));
2094   if(x<0.0 && y < 0.0)    alpha = TMath::Abs(TMath::ATan(TMath::Abs(x/y)));
2095   if(x<0.0 && y > 0.0)    alpha = TMath::Abs(TMath::ATan(TMath::Abs(y/x)));
2096   
2097   if(x>0.0 && y < 0.0)    alpha += (    TMath::Pi()/2);
2098   if(x<0.0 && y < 0.0)    alpha += (    TMath::Pi());
2099   if(x<0.0 && y > 0.0)    alpha += (1.5*TMath::Pi());
2100   
2101   sector =   (Int_t)(alpha/(2*TMath::Pi()/18.0));
2102   if(alpha> (sector+0.5)*(2*TMath::Pi()/18.0))  sector+=1;
2103   
2104   if(sector==18 && side ==0 ) {
2105     AliWarning("There was a wromg assignment of sector 0 with sector 18. Check sectors");
2106     sector =0;
2107   }
2108   
2109   sector = (18-sector +4)%18;
2110   SetLastSector(sector+ side*18);
2111   SetProcNextEvent(0);
2112   
2113   if(fVerb) cout << "AliTPCMonitor::ExecProcess()  next side          " <<   side    << " next sector        " <<    sector  << endl;
2114   
2115   return (Int_t)ProcessEvent();
2116   
2117 }
2118
2119 //__________________________________________________________________
2120 Int_t AliTPCMonitor::GetRCUPatch(Int_t runid, Int_t eqid) const
2121 {
2122   
2123   // Return RCU patch index for given equipment id eqid
2124   Int_t patch = 0;
2125   //if(runid>=704)
2126   if(runid>=0)
2127   {
2128     if ( eqid<768 || eqid>983 ) return 0; //no TPC eqid
2129     if(eqid>=1000) return 0;
2130     patch = fMapEqidsRcu[eqid] ;
2131   }
2132   else
2133   {
2134     if(eqid==408) {patch =  13*6+4 +0;  }
2135     if(eqid==409) {patch =  13*6+5 +0;  }
2136     if(eqid==509) {patch =  13*6+0 +0;  }
2137     if(eqid==512) {patch =  13*6+3 +0;  }
2138     if(eqid==513) {patch =  13*6+1 +0;  }
2139     if(eqid==517) {patch =  13*6+2 +0;  }
2140     
2141     if(eqid==404) {patch =  4*6+5 +0;   }
2142     if(eqid==504) {patch =  4*6+4 +0;   }
2143     if(eqid==407) {patch =  4*6+3 +0;   }
2144     if(eqid==503) {patch =  4*6+2 +0;   }
2145     if(eqid==508) {patch =  4*6+1 +0;   }
2146     if(eqid==506) {patch =  4*6+0 +0;   }
2147   }
2148   return patch;
2149 }
2150
2151 //__________________________________________________________________
2152 void AliTPCMonitor::DumpHeader(AliRawReader * reader) const
2153 {
2154   // Dump Event header for  format
2155   
2156   cout << "EventHeader     : fReader->GetEquipmentSize()            :" << reader->GetEquipmentSize()        << endl;
2157   cout << "EventHeader     : fReader->GetType()                     :" << reader->GetType()                 << endl;
2158   cout << "EventHeader     : fReader->GetRunNumber()                :" << reader->GetRunNumber()            << endl;
2159   cout << "EventHeader     : fReader->GetEventId()                  :" << *(reader->GetEventId())           << endl;
2160   cout << "EventHeader     : fReader->GetLDCId()                    :" << reader->GetLDCId()                << endl;
2161   cout << "EventHeader     : fReader->GetGDCId()                    :" << reader->GetGDCId()                << endl;
2162 }
2163
2164
2165 //__________________________________________________________________
2166 Double_t AliTPCMonitor::Gamma4(Double_t* x, Double_t* par) {
2167   
2168   // Gamma4 function used to fit signals
2169   // Defined in sections: diverging branch set to 0
2170   
2171   Double_t val  = 0.0;
2172   if(x[0] > par[1])
2173     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];
2174   else
2175     val = 0;
2176   return val;
2177 }
2178
2179 //__________________________________________________________________
2180 TCanvas* AliTPCMonitor::CreateCanvas(const Char_t* name)
2181 {
2182   // Create Canvases
2183   
2184   TCanvas* canv =0;
2185   
2186   Int_t xoffset  = GetCanvasXOffset();
2187   Int_t xsize    = GetCanvasXSize();
2188   Int_t ysize    = GetCanvasYSize();
2189   Int_t xspace   = GetCanvasXSpace();
2190   Int_t yspace   = GetCanvasYSpace();
2191
2192   TString sname=name;
2193   // ROC 2dim max distribution
2194   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;  }
2195   else if(sname=="ciroc") {    canv   = new TCanvas("ciroc"         ,"ciroc"      ,                   -1+xoffset,                     0    ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv;  }
2196   // ROC  2dim rms distribution
2197   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;  }
2198   else if(sname=="crmsiroc") {    canv   = new TCanvas("crmsiroc"      ,"crmsiroc"   ,                   -1+xoffset,                        0 ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv;  }
2199   // Global ADC max Histos
2200   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;  }
2201   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;  }
2202   // 1 dim max sum basekine distribution
2203   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;  }
2204   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;  }
2205   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;  }
2206   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;  }
2207   // Projections of single channel
2208   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;  }
2209   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;  }
2210   // FFT for single channel
2211   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;  }
2212   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;  }
2213   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;  }
2214   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;  }
2215   // row profile histograms
2216   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;  }
2217   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;  }
2218   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;  }
2219   else                                      {    cout   << " Warning Canvas name unknown "  << endl;                                                                                                  return 0   ;  }
2220 }
2221
2222 //__________________________________________________________________
2223 void AliTPCMonitor::WriteHistos()  
2224 {
2225   // Writes all available histograms to a file in current directory
2226   // File name will be specified by : sector, side, runid and eventnumber
2227   
2228   if(GetEventProcessed())
2229   {
2230     AliInfo("Write histos to file");
2231     TString name=Form("SIDE_%i_SECTOR_%02i_RUN_%05i_EventID_%06i.root",(GetLastSector()/18),(GetLastSector()%18),fRunId,fEventNumber);
2232     TFile* f = new TFile(name.Data(),"recreate");
2233     for(Int_t i =0; i<fHistList->GetEntries(); i++)
2234     {
2235       if(((TH1*)fHistList->At(i))!=0)
2236       {
2237         ((TH1*)fHistList->At(i))->Write();
2238       }
2239     }
2240     f->ls();
2241     f->Close();
2242   }
2243   else
2244   {
2245     AliError("No Event Processed : Chose Format , File and push 'Next Event' ");
2246   }
2247 }
2248
2249
2250 //__________________________________________________________________
2251 TH1* AliTPCMonitor::GetHisto(char* histname) 
2252 {
2253   
2254   // Returns histogram specified by histname
2255   // check available names for histos in CreateHistos()
2256   
2257   TH1* hist = 0;
2258   if((TH1*)fHistList->FindObject(histname))
2259   {
2260     hist = (TH1*)fHistList->FindObject(histname);
2261   }
2262   else
2263   {
2264     cout << " AliTPCMonitor::GetHisto :: Can not find histo with name " << histname << endl;
2265   }
2266   return hist ;
2267 }