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