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