]> 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 out of range protection (Marian)
[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 {
48265b32 930 //Int_t hw_before1 = fPad[fChannelIter-2][0];
931 //Int_t hw_before2 = fPad[fChannelIter-3][0];
932
933 if(fVerb){ cout <<"\n //// Ambiguous hwaddress " << nextHwAddress << " write 10bit files and check file for eqid : " << fEqId << " /////// " << endl;}
c4607f01 934 return;
48265b32 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);
c4607f01 1256 if (sector%36>17) fMirror=-1;
1257 else fMirror=1;
48265b32 1258 GetXY(xval ,yval , padmax,row ,pad);
1259 xdr = xval*m11 +yval*m12;
1260 ydr = xval*m21 +yval*m22;
1261 if(hglob->GetBinContent(hglob->GetXaxis()->FindBin(xdr),hglob->GetYaxis()->FindBin(ydr))==0) hglob->Fill(xdr,ydr,(Int_t)max);
1262 }
1263 }
1264}
1265
1266
1267//__________________________________________________________________
ca7b8371 1268void AliTPCMonitor::GetXY( Double_t& xval , Double_t& yval , Int_t padmax, Int_t row , Int_t pad) const
48265b32 1269{
1270 // Get x and y position of pad
1271
1272 if(row<63)
1273 {
1274 xval = fMirror*( 2*padmax -4*pad -2);
1275 yval = 852.25 +7.5*row;
1276 }
1277 else
1278 {
1279 xval = fMirror*( 3*padmax -6*pad -3);
1280 if((row-63)<63) { yval = 10*(row-63) +1351; }
1281 else { yval = 15*(row-63-64)+1993.5; }
1282 }
1283
1284}
1285
1286//__________________________________________________________________
ca7b8371 1287Int_t AliTPCMonitor::GetPadAtX(Float_t xval, Int_t row, Int_t padmax) const
48265b32 1288{
1289 // Get pad number at given position in x
1290 Int_t pad = 0;
1291
1292 if(row<63) {pad = (Int_t)( ( (xval/fMirror) +2 -2*padmax)/-4);}
1293 else {pad = (Int_t)( ( (xval/fMirror) +3 -3*padmax)/-6);}
1294
1295 if(pad>=padmax) return -1;
1296 else return pad ;
1297
1298}
1299
1300//__________________________________________________________________
ca7b8371 1301Int_t AliTPCMonitor::GetPadAtX(Float_t xval, Int_t row) const
48265b32 1302{
1303
1304 // Get pad number at given position in x
1305
1306 Int_t padmax = fMapHand->GetNumofPads(row);
1307 Int_t pad = 0;
1308
1309 if(row<63) {pad = (Int_t)( ( (xval/fMirror) +2 -2*padmax)/-4);}
1310 else {pad = (Int_t)( ( (xval/fMirror) +3 -3*padmax)/-6);}
1311
1312 if(pad>=padmax) return -1;
1313 else return pad ;
1314
1315}
1316
1317//__________________________________________________________________
1318void AliTPCMonitor::DrawHists(Int_t histos)
1319{
1320
1321 // Draw sets of histograms
1322 // histos==1 : 2Dim histos for MAX adc and add executables
1323 // histos==2 : distributions max/rms/sum
1324 // histos==3 : global max adc for specified SideA/C
1325
1326
1327 if(fVerb) cout << " Draw histos " << endl;
1328 Char_t cside[10];
1329 if(GetLastSector()/18==0 ) sprintf(cside,"A");
1330 else sprintf(cside,"C");
1331
1332 Char_t titleSEC[256]; sprintf(titleSEC ,"Sector %i Side %s Run : %05i EventID %i " ,GetLastSector()%18,cside,fRunId, fEventNumber);
1333 Char_t titleEvent[256]; sprintf(titleEvent ,"Time <-> Channles %s" ,titleSEC);
1334 Char_t titleIROC[256]; sprintf(titleIROC ,"IROC %s" ,titleSEC);
1335 Char_t titleOROC[256]; sprintf(titleOROC ,"OROC %s" ,titleSEC);
1336
1337 Char_t titleMAX[256]; sprintf(titleMAX ,"Max (timebin: %i,%i) %s" ,GetRangeMaxAdcMin(),GetRangeMaxAdcMax(),titleSEC);
1338 Char_t titleSUM[256]; sprintf(titleSUM ,"Sum (timebin: %i,%i) %s" ,GetRangeSumMin() ,GetRangeSumMax() ,titleSEC);
1339 Char_t titleBASE[256]; sprintf(titleBASE ,"Baseline RMS<->Mean (timebin: %i-%i) %s" ,GetRangeBaseMin() ,GetRangeBaseMax() ,titleSEC);
1340 Char_t titleMEAN[256]; sprintf(titleMEAN ,"Baseline Mean (timebin: %i-%i) %s" ,GetRangeBaseMin() ,GetRangeBaseMax() ,titleSEC);
1341 Char_t titleRMS[256] ; sprintf(titleRMS ,"Baseline RMS (timebin: %i-%i) %s" ,GetRangeBaseMin() ,GetRangeBaseMax() ,titleSEC);
1342
1343 if(histos==1)
1344 {
1345 // IROC _______________________________________________________________
1346 TCanvas* ciroc = 0;
1347 ciroc = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("ciroc");
1348 if(!ciroc)
1349 {
1350 ciroc = CreateCanvas("ciroc");
1351 fExecPlaneMax=0;
1352 }
1353 ciroc->cd();
1354
1355 fHistIROC->SetXTitle("row");
1356 fHistIROC->SetYTitle("pad");
1357 if(GetPedestals()) fHistIROC->SetZTitle("max ADC (baseline sub)");
1358 else fHistIROC->SetZTitle("max ADC ");
1359 fHistIROC->SetTitle(titleIROC);
1360 fHistIROC->SetMinimum(0.01);
1361 fHistIROC->Draw("COLZ");
1362 ciroc->UseCurrentStyle();
1363
1364
1365 fHistIROCTime->SetXTitle("row"); fHistIROCTime->SetZTitle("peak time (fit)"); fHistIROCTime->SetYTitle("pad"); fHistIROCTime->SetTitle(titleIROC);
1366 fHistIROCRMS->SetXTitle("row"); fHistIROCRMS->SetZTitle( "baseline rms (ADC)"); fHistIROCRMS->SetYTitle("pad"); fHistIROCRMS->SetTitle(titleIROC);
1367
1368 // OROC
1369 TCanvas* coroc = 0;
1370 coroc =(TCanvas*)gROOT->GetListOfCanvases()->FindObject("coroc");
1371 if(!coroc) {
1372 coroc = CreateCanvas("coroc");
1373 fExecPlaneMax=0;
1374 }
1375 coroc->cd();
1376
1377 fHistOROC->SetXTitle("row");
1378 fHistOROC->SetYTitle("pad");
1379 if(GetPedestals()) fHistOROC->SetZTitle("max ADC (baseline sub)");
1380 else fHistOROC->SetZTitle("max ADC ");
1381 fHistOROC->SetTitle(titleOROC);
1382 fHistOROC->SetMinimum(0.01);
1383 fHistOROC->Draw("COLZ");
1384 coroc->UseCurrentStyle();
1385
1386
1387 fHistOROCTime->SetXTitle("row"); fHistOROCTime->SetZTitle("peak time (fit) (timebins)"); fHistOROCTime->SetYTitle("pad"); fHistOROCTime->SetTitle(titleOROC);
1388 fHistOROCRMS->SetXTitle("row"); fHistOROCRMS->SetZTitle("baseline rms (ADC)"); fHistOROCRMS->SetYTitle("pad"); fHistOROCRMS->SetTitle(titleOROC);
1389
1390 // SUM
ca7b8371 1391 Char_t namesum[256] ; sprintf(namesum,"ADC sum (bins: %i, %i)",GetRangeSumMin() ,GetRangeSumMax() );
1392 fHistIROCSUM->SetXTitle("row"); fHistIROCSUM->SetZTitle(namesum); fHistIROCSUM->SetYTitle("pad"); fHistIROCSUM->SetTitle(titleIROC);
1393 fHistOROCSUM->SetXTitle("row"); fHistOROCSUM->SetZTitle(namesum); fHistOROCSUM->SetYTitle("pad"); fHistOROCSUM->SetTitle(titleOROC);
48265b32 1394
1395 // BASE
ca7b8371 1396 Char_t namebase[256] ; sprintf(namebase ,"base mean (timbebin: %i, %i )",GetRangeBaseMin(),GetRangeBaseMax());
1397 fHistIROCBASE->SetXTitle("row"); fHistIROCBASE->SetZTitle(namebase); fHistIROCBASE->SetYTitle("pad"); fHistIROCBASE->SetTitle(titleIROC);
1398 fHistOROCBASE->SetXTitle("row"); fHistOROCBASE->SetZTitle(namebase); fHistOROCBASE->SetYTitle("pad"); fHistOROCBASE->SetTitle(titleOROC);
48265b32 1399
1400 if(fHistIROCClone) fHistIROCClone->Delete();
1401 if(fHistOROCClone) fHistOROCClone->Delete();
1402 fHistIROCClone = (TH2F*)fHistIROC->Clone("fHistIROCClone");
1403 fHistOROCClone = (TH2F*)fHistOROC->Clone("fHistOROCClone");
1404
1405 // Executables
1406 if(fExecPlaneMax==0)
1407 {
1408 Char_t carry1[100];
1409 sprintf(carry1,".x %s/TPC/AliTPCMonitorExec.C(1)",gSystem->Getenv("ALICE_ROOT"));
1410 ciroc->AddExec("pad",carry1);
1411 coroc->AddExec("pad",carry1);
1412
1413 Char_t carry2[100];
1414 sprintf(carry2,".x %s/TPC/AliTPCMonitorExec.C(2)",gSystem->Getenv("ALICE_ROOT"));
1415 ciroc->AddExec("row",carry2);
1416 coroc->AddExec("row",carry2);
1417 fExecPlaneMax=1;
1418 }
1419 coroc->Update();
1420 ciroc->Update();
1421 }
1422 else if(histos==2)
1423 {
1424 // MAX ADC distribution ____________________________________________
1425 TCanvas* cmax = 0;
1426 cmax = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("cmax");
1427 if(!cmax) cmax = CreateCanvas("cmax");
1428
1429 cmax->cd();
1430 fHistDistrMaxIROC->GetXaxis()->SetRangeUser(0.0,1000.0);
1431 fHistDistrMaxIROC->SetXTitle("max ADC (ADC)");
1432 fHistDistrMaxIROC->SetYTitle("counts");
1433 fHistDistrMaxIROC->SetTitle(titleMAX);
1434 fHistDistrMaxIROC->Draw("");
1435 fHistDistrMaxOROC->SetLineColor(2);
1436 fHistDistrMaxOROC->Draw("same");
1437
1438 if(fHistDistrMaxOROC->GetMaximum()> fHistDistrMaxIROC->GetMaximum()) fHistDistrMaxIROC->SetMaximum(fHistDistrMaxOROC->GetMaximum()*1.1);
1439
1440 TLegend* legio = new TLegend(0.6,0.6,0.8,0.8);
1441 legio->SetFillColor(0);
1442 legio->AddEntry(fHistDistrMaxIROC,"IROC","l");
1443 legio->AddEntry(fHistDistrMaxOROC,"OROC","l");
1444 legio->Draw("same");
1445
1446 // ADC sum distribution
1447 TCanvas* csum = 0;
1448 csum = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("csum");
1449 if(!csum) csum = CreateCanvas("csum") ;
1450 csum->cd();
1451
1452 fHistDistrSumIROC->SetXTitle("sum ADC (ADC)");
1453 fHistDistrSumIROC->SetYTitle("counts");
1454 fHistDistrSumIROC->SetTitle(titleSUM);
1455 fHistDistrSumIROC->Draw("");
1456 fHistDistrSumOROC->SetLineColor(2);
1457 fHistDistrSumOROC->Draw("same");
1458 if(fHistDistrSumOROC->GetMaximum()> fHistDistrSumIROC->GetMaximum()) fHistDistrSumIROC->SetMaximum(fHistDistrSumOROC->GetMaximum()*1.1);
1459 legio->Draw("same");
1460
1461 // BASELINE MEAN distribution
1462 TCanvas* cbasemean = 0;
1463 cbasemean = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("cbasemean");
1464 if(!cbasemean) cbasemean = CreateCanvas("cbasemean");
1465 cbasemean->cd();
1466
1467 fHistDistrBaseMeanIROC = fHistDistrBase2dIROC->ProjectionX("fHistDistrBaseMeanIROC");
1468 fHistDistrBaseMeanIROC->SetXTitle("base mean (ADC)");
1469 fHistDistrBaseMeanIROC->SetYTitle("counts");
1470 fHistDistrBaseMeanIROC->SetTitle(titleMEAN);
1471 fHistDistrBaseMeanIROC->Draw("");
1472
1473 fHistDistrBaseMeanOROC = fHistDistrBase2dOROC->ProjectionX("fHistDistrBaseMeanOROC");
1474 fHistDistrBaseMeanOROC->SetLineColor(2);
1475 fHistDistrBaseMeanOROC->Draw("same");
1476 if(fHistDistrBaseMeanOROC->GetMaximum()>fHistDistrBaseMeanIROC->GetMaximum()) fHistDistrBaseMeanIROC->SetMaximum(fHistDistrBaseMeanOROC->GetMaximum()*1.1);
1477 legio->Draw("same");
1478
1479 TCanvas* cbaserms = 0;
1480 cbaserms = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("cbaserms");
1481 if(!cbaserms) cbaserms = CreateCanvas("cbaserms") ;
1482 cbaserms->cd();
1483
1484 // BASELINE RMS distribution
1485 fHistDistrBaseRmsIROC = fHistDistrBase2dIROC->ProjectionY("fHistDistrBaseRmsIROC");
1486 fHistDistrBaseRmsIROC->SetXTitle("base rms (ADC)");
1487 fHistDistrBaseRmsIROC->SetYTitle("counts");
1488 fHistDistrBaseRmsIROC->SetTitle(titleRMS);
1489 fHistDistrBaseRmsIROC->Draw("");
1490
1491 fHistDistrBaseRmsOROC = fHistDistrBase2dOROC->ProjectionY("fHistDistrBaseRmsOROC");
1492 fHistDistrBaseRmsOROC->SetLineColor(2);
1493 fHistDistrBaseRmsOROC->Draw("same");
1494 if(fHistDistrBaseRmsOROC->GetMaximum()>fHistDistrBaseRmsIROC->GetMaximum()) fHistDistrBaseRmsIROC->SetMaximum(fHistDistrBaseRmsOROC->GetMaximum()*1.1);
1495 legio->Draw("same");
1496
1497 cmax->Update();
1498 csum->Update();
1499 cbasemean->Update();
1500 cbaserms->Update();
1501 }
1502 else if(histos==3)
1503 {
1504 // GLOBAL MAX ADC _________________________________
1505 if(GetProcNextEvent()==1)
1506 {
1507 TCanvas* cglobA =0;
1508 TCanvas* cglobC =0;
1509
1510 if(!(cglobC=(TCanvas*)gROOT->GetListOfCanvases()->FindObject("SIDE C all"))) cglobC = CreateCanvas("SIDE C all");
1511 if(!(cglobA=(TCanvas*)gROOT->GetListOfCanvases()->FindObject("SIDE A all"))) cglobA = CreateCanvas("SIDE A all");
1512
ca7b8371 1513 Char_t globtitle1[256]; sprintf(globtitle1,"SIDE A Run %05i (EventID %i)",fRunId,fEventNumber);
1514 Char_t globtitle2[256]; sprintf(globtitle2,"SIDE C Run %05i (EventID %i)",fRunId,fEventNumber);
48265b32 1515
ca7b8371 1516 fHistGlobalMaxA->SetTitle(globtitle1);
1517 fHistGlobalMaxC->SetTitle(globtitle2);
48265b32 1518 fHistGlobalMaxA->SetXTitle("x/mm");
1519 fHistGlobalMaxA->SetYTitle("y/mm");
1520 fHistGlobalMaxC->SetXTitle("x/mm");
1521 fHistGlobalMaxC->SetYTitle("y/mm");
1522
1523 if(GetPedestals()==0) { fHistGlobalMaxA->SetZTitle("max adc (not baseline sub)"); fHistGlobalMaxC->SetZTitle("max adc (not baseline sub)"); }
1524 else { fHistGlobalMaxA->SetZTitle("max adc "); fHistGlobalMaxC->SetZTitle("max adc "); }
1525
1526 fHistGlobalMaxA->SetMinimum(0.01);
1527 fHistGlobalMaxC->SetMinimum(0.01);
1528
1529 cglobC->cd() ; fHistGlobalMaxC->Draw("COLZ");
1530 cglobA->cd() ; fHistGlobalMaxA->Draw("COLZ");
1531
ca7b8371 1532 Char_t nameom[256];
1533 sprintf(nameom,".x %s/TPC/AliTPCMonitorExec.C(3)",gSystem->Getenv("ALICE_ROOT"));
48265b32 1534
1535 if(fExecGlob==0)
1536 {
ca7b8371 1537 if(fVerb)cout << " set exec " << nameom << endl;
1538 cglobC->AddExec("glob",nameom);
1539 cglobA->AddExec("glob",nameom);
48265b32 1540 fExecGlob = 1;
1541 }
1542 else
1543 {
1544 cglobC->DeleteExec("glob");
1545 cglobA->DeleteExec("glob");
1546
ca7b8371 1547 if(fVerb) cout << " set exec " << nameom << endl;
1548 cglobC->AddExec("glob",nameom);
1549 cglobA->AddExec("glob",nameom);
48265b32 1550
1551 }
1552 cglobC->Update();
1553 cglobA->Update();
1554 }
1555
1556 }
1557}
1558
1559
1560
1561//__________________________________________________________________
1562void AliTPCMonitor::DrawRMSMap()
1563{
1564 // Draw 2Dim rms histos for IROC and OROC
1565 // and set executables for canvases
1566
1567 TCanvas* crmsoroc =0;
1568 TCanvas* crmsiroc =0;
1569 if(!(crmsoroc = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("crmsoroc"))) crmsoroc = CreateCanvas("crmsoroc");
1570 if(!(crmsiroc = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("crmsiroc"))) crmsiroc = CreateCanvas("crmsiroc");
1571
1572 crmsiroc->cd(); fHistIROCRMS->Draw("COLZ");
1573 crmsoroc->cd(); fHistOROCRMS->Draw("COLZ");
1574
1575 Char_t carry1[100]; sprintf(carry1,".x %s/TPC/AliTPCMonitorExec.C(1)",gSystem->Getenv("ALICE_ROOT"));
1576 Char_t carry2[100]; sprintf(carry2,".x %s/TPC/AliTPCMonitorExec.C(2)",gSystem->Getenv("ALICE_ROOT"));
1577
1578 if(fExecPadIrocRms==0)
1579 {
1580 crmsiroc->AddExec("pad",carry1);
1581 crmsiroc->AddExec("row",carry2);
1582 fExecPadIrocRms=1;
1583 }
1584
1585 if(fExecPadOrocRms==0)
1586 {
1587 crmsoroc->AddExec("pad",carry1);
1588 crmsoroc->AddExec("row",carry2);
1589 fExecPadOrocRms=1;
1590 }
1591
1592 crmsiroc->Update();
1593 crmsoroc->Update();
1594
1595 DrawHists(2);
1596
1597}
1598
1599//__________________________________________________________________
1600void AliTPCMonitor::ExecPad()
1601{
1602
1603 // Executable for Pad
1604 // Show time profile for channel the mouse is pointing at
1605
1606 Int_t event = gPad->GetEvent();
1607 if (event != 51) return;
1608
1609 TObject *select = gPad->GetSelected();
1610 if(!select) return;
1611 if(!select->InheritsFrom("TH2")) { return; }
1612 gPad->GetCanvas()->FeedbackMode(kTRUE);
1613
1614 // get position
1615 Int_t px = gPad->GetEventX();
1616 Int_t py = gPad->GetEventY();
1617 Float_t upy = gPad->AbsPixeltoY(py);
1618 Float_t upx = gPad->AbsPixeltoX(px);
1619 Float_t y = gPad->PadtoY(upy);
1620 Float_t x = gPad->PadtoX(upx);
1621
1622 Int_t setrange = 0;
1623
1624 TCanvas* cpad = 0;
1625 // Char_t namehist[50];
1626 Char_t projhist[60];
1627 Char_t namesel[256];
1628 Char_t namecanv[256];
1629
ca7b8371 1630 Int_t xbinmin = 0;
1631 Int_t xbinmax = 0;
1632 Float_t ybinmin = 0;
1633 Float_t ybinmax = 0;
1634 Int_t rocid = 0;
48265b32 1635
1636 // Check wich Canvas executed the event
1637 TH2S* fHistIndex=0;
1638 sprintf(namesel,select->GetName());
1639 if(strcmp(namesel,"fHistOROC")==0 || strcmp(namesel,"fHistOROCRMS")==0 || strcmp(namesel,"fHistOROCTime")==0 )
1640 {
ca7b8371 1641 rocid = 1;
48265b32 1642 fPadUsedRoc =1;
1643 sprintf(projhist,"ProjectionOROC");
1644 sprintf(namecanv,"coroc_ch");
1645 fHistIndex = fHistOROCIndex;
1646 }
1647 if(strcmp(namesel,"fHistIROC")==0 || strcmp(namesel,"fHistIROCRMS")==0 || strcmp(namesel,"fHistIROCTime")==0 )
1648 {
ca7b8371 1649 rocid = 0;
48265b32 1650 fPadUsedRoc=0;
1651 sprintf(projhist,"ProjectionIROC");
1652 sprintf(namecanv,"ciroc_ch");
ca7b8371 1653 fHistIndex = fHistIROCIndex;
48265b32 1654 }
1655
1656 // Check if Canvas already existed and get Ranges from former Prjection histogram
ca7b8371 1657 if((cpad=(TCanvas*)gROOT->GetListOfCanvases()->FindObject(namecanv)))
48265b32 1658 {
1659 cpad->cd();
1660 if(gROOT->Get(projhist))
1661 {
1662 setrange = 1;
ca7b8371 1663 xbinmin = ((TH1D*)gROOT->Get(projhist))->GetXaxis()->GetFirst();
1664 xbinmax = ((TH1D*)gROOT->Get(projhist))->GetXaxis()->GetLast();
1665 ybinmin = ((TH1D*)gROOT->Get(projhist))->GetMinimum();
1666 ybinmax = ((TH1D*)gROOT->Get(projhist))->GetMaximum();
48265b32 1667 delete gROOT->Get("legfit");
1668 delete gROOT->Get("fg");
1669 }
1670 }
1671 else
1672 {
1673 cpad = CreateCanvas(namecanv); cpad->cd();
1674 }
1675
1676 // Get Bin
1677 Int_t testy = fHistIndex->GetYaxis()->FindBin(y);
1678 Int_t testx = fHistIndex->GetXaxis()->FindBin(x);
1679 Int_t binchannel = (Int_t)fHistIndex->GetCellContent(testx,testy);
1680 if(binchannel>30000 || binchannel<0) return;
1681
1682 if(gROOT->Get(projhist)) delete gROOT->Get(projhist);
1683 // Get Projection
1684 TH1D *hp = (TH1D*)(((TH1D*)fHistChannelTime->ProjectionY("hp",binchannel,binchannel))->Clone(projhist));
1685
1686 // Make title and Pave for channel Info
1687 Char_t title[256];
1688 Int_t npadRow , npad , nhw , nmax , hwadd;
1689
1690 hwadd = (Int_t)fHistChannelTime->GetCellContent(binchannel,0);
1691 fPadUsedHwAddr = hwadd;
1692
ca7b8371 1693 if(rocid==0)npadRow = fMapHand->GetPadRow(hwadd);
1694 else npadRow = fMapHand->GetPadRow(hwadd)-63;
1695 npad = fMapHand->GetPad(hwadd);
1696 nhw = hwadd;
1697 nmax = (Int_t)hp->GetMaximum();
48265b32 1698
1699
1700 TPaveText* legstat = new TPaveText(0.18,0.65,0.3,0.8,"NDC");
1701
1702 Int_t connector = fMapHand->GetFECconnector(hwadd);
ca7b8371 1703 Int_t fecnr = fMapHand->GetFECfromHw(hwadd);
1704 Int_t fecch = fMapHand->GetFECchannel(hwadd);
1705 Int_t altrochip = fMapHand->GetAltro(hwadd);
1706 Int_t altrochannel= (fMapHand->GetAltroChannel(hwadd))%16;
1707 Int_t fecloc = fMapHand->U2fGetFECinRCU(fecnr) ;
1708 Int_t feclocbran = fMapHand->U2fGetFECinBranch(fecnr);
1709 Int_t branch = fMapHand->U2fGetBranch(fecnr);
48265b32 1710
1711
1712 Short_t fecget = (hwadd & AliTPCMonitorAltro::GetHwMaskFEC()) >> 7;
1713 Short_t branchget = (hwadd & AliTPCMonitorAltro::GetHwMaskBranch())>> 11;
1714
1715
1716 Char_t nstat1[100]; Char_t nstat2[100]; Char_t nstat3[100]; Char_t nstat4[100];
1717 Char_t nstat5[100]; Char_t nstat6[100]; Char_t nstat7[100]; Char_t nstat8[100];
1718
1719 sprintf(nstat1,"Branch (map) \t %i (%i) \n",branchget,branch);
ca7b8371 1720 sprintf(nstat2,"Fec in patch \t %i \n",fecloc);
1721 sprintf(nstat8,"Fec in branch (map)\t %i (%i)\n",fecget,feclocbran);
48265b32 1722 sprintf(nstat7,"Connector \t %i \n",connector);
ca7b8371 1723 sprintf(nstat3,"Fec No. \t %i \n",fecnr);
1724 sprintf(nstat4,"Fec chan \t %i \n",fecch);
1725 sprintf(nstat5,"Altro chip\t %i \n",altrochip);
1726 sprintf(nstat6,"Altro chan\t %i \n",altrochannel);
48265b32 1727
1728 legstat->AddText(nstat1); legstat->AddText(nstat2); legstat->AddText(nstat8); legstat->AddText(nstat7);
1729 legstat->AddText(nstat3); legstat->AddText(nstat4); legstat->AddText(nstat5); legstat->AddText(nstat6);
1730
1731 sprintf(title,"Row=%d Pad=%d Hw =%d maxADC =%d count =%d",npadRow,npad,nhw,nmax,binchannel);
1732
1733 hp->SetName(projhist);
1734 hp->SetTitleSize(0.04);
1735 hp->SetTitle(title);
1736 hp->SetYTitle("ADC");
1737 hp->SetXTitle("Timebin");
1738 hp->GetXaxis()->SetTitleColor(1);
1739
1740 if(setrange)
1741 {
ca7b8371 1742 hp->GetXaxis()->SetRange(xbinmin,xbinmax);
1743 hp->SetMinimum(ybinmin);
1744 hp->SetMaximum(ybinmax);
48265b32 1745 }
1746 else
1747 {
1748 hp->SetMinimum(0.0);
1749 hp->SetMaximum(1000.0);
1750 }
1751
1752 cpad->cd();
1753 hp->Draw();
1754
1755 // Make Fit to peak
1756 if(GetPedestals() && fDisableFit==0)
1757 {
ca7b8371 1758 Int_t maxx = (Int_t)fHistAddrMaxAdcX->GetBinContent(hwadd);
48265b32 1759 Float_t max = (Float_t)fHistAddrMaxAdc->GetBinContent(hwadd);
1760 Float_t base = (Float_t)fHistAddrBaseMean->GetBinContent(hwadd);
1761 if(base!=0)
1762 {
1763 if( ((max+base)/base)>1.2)
1764 {
ca7b8371 1765 TF1* fg = new TF1("fg",AliTPCMonitor::Gamma4,maxx-5,maxx+5,4);
48265b32 1766 fg->SetParName(0,"Normalisation");
1767 fg->SetParName(1,"Minimum");
1768 fg->SetParName(2,"Width");
1769 fg->SetParName(3,"Base");
1770 fg->SetParameter(0,max);
ca7b8371 1771 fg->SetParameter(1,maxx-2);
48265b32 1772 fg->SetParameter(2,1.5);
1773 fg->FixParameter(3,0);
1774 fg->SetLineColor(4);
1775 fg->SetLineWidth(1);
1776 hp->Fit("fg","RQ");
1777
1778 TLegend* legfit = new TLegend(0.6,0.7,0.7,0.8);
1779 legfit->AddEntry("fg","#Gamma 4 fit","l");
1780 legfit->SetFillColor(0);
1781 legfit->SetName("legfit");
1782 legfit->Draw("same");
1783 }
1784 }
1785 }
1786 legstat->SetFillColor(0);
1787 legstat->Draw("same");
1788 cpad->Update();
1789 return;
1790}
1791
1792//__________________________________________________________________
1793void AliTPCMonitor::ExecRow()
1794{
1795
1796 // Executable for Pad
1797 // Show profile of max adc over given pad row
1798 // and 2dim histo adc(pad-in-row,time bin)
1799
1800 Int_t event = gPad->GetEvent();
1801 if (event != 61) return;
1802 gPad->cd();
1803 TObject *select = gPad->GetSelected();
1804 if(!select) return;
1805 if(!select->InheritsFrom("TH2")) { return; }
1806
ca7b8371 1807 Int_t rocid = 0;
48265b32 1808 // Char_t namehist[50];
1809 Char_t rowhist[60];
ca7b8371 1810 Char_t rowhistsum[60];
1811 Char_t rowhistmax[60];
1812 Char_t rowhistxmax[60];
48265b32 1813
ca7b8371 1814 sprintf(rowhist, "hrowtime");
1815 sprintf(rowhistxmax ,"hxmax");
1816 sprintf(rowhistmax , "hrowmax");
48265b32 1817
1818 // get position
1819 Int_t px = gPad->GetEventX();
1820 Int_t py = gPad->GetEventY();
1821 Float_t upy = gPad->AbsPixeltoY(py);
1822 Float_t upx = gPad->AbsPixeltoX(px);
1823 Float_t y = gPad->PadtoY(upy);
1824 Float_t x = gPad->PadtoX(upx);
1825
ca7b8371 1826 TCanvas*crowtime = 0;
1827 TCanvas*crowmax = 0;
1828 TCanvas*cxmax = 0;
48265b32 1829
1830 TH2S* fHistIndex = 0;
1831
1832 // ranges from already existing histos
ca7b8371 1833 Int_t rowtimexmin = 0;
1834 Int_t rowtimexmax = 0;
1835 Int_t rowtimeymin = 0;
1836 Int_t rowtimeymax = 0;
1837 Float_t rowtimezmin = 0;
1838 Float_t rowtimezmax = 0;
48265b32 1839
fb3305d1 1840 Int_t profrowxmin = 0;
1841 Int_t profrowxmax = 0;
1842 Double_t profrowymin = 0;
1843 Double_t profrowymax = 0;
48265b32 1844
ca7b8371 1845 Int_t profxxmin = 0;
1846 Int_t profxxmax = 0;
1847 Double_t profxymin = 0;
1848 Double_t profxymax = 0;
48265b32 1849
1850
1851 Int_t setrange = 0;
1852
1853
ca7b8371 1854 if( strcmp(select->GetName(),"fHistIROC")==0 || strcmp(select->GetName(),"fHistIROCRMS")==0 ) { fHistIndex = fHistIROCIndex; rocid =1; }
1855 else if(strcmp(select->GetName(),"fHistOROC")==0 || strcmp(select->GetName(),"fHistOROCRMS")==0 ) { fHistIndex = fHistOROCIndex; rocid =2; }
48265b32 1856 else { cout << " not implemented for this histo " << endl; return; }
1857
1858 gPad->GetCanvas()->FeedbackMode(kTRUE);
1859
1860
1861
1862 // check if canvases exist //
ca7b8371 1863 crowtime = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("crowtime");
1864 crowmax = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("crowmax");
1865 cxmax = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("cxmax");
48265b32 1866
ca7b8371 1867 if(!crowtime) crowtime = CreateCanvas("crowtime") ;
1868 if(!crowmax) crowmax = CreateCanvas("crowmax") ;
1869 if(!cxmax ) cxmax = CreateCanvas("cxmax") ;
48265b32 1870
1871 // check ranges of already existing histos
1872 if(gROOT->Get(rowhist))
1873 {
ca7b8371 1874 rowtimexmin = ((TH2F*)gROOT->Get(rowhist))->GetXaxis()->GetFirst();
1875 rowtimexmax = ((TH2F*)gROOT->Get(rowhist))->GetXaxis()->GetLast();
1876 rowtimeymin = ((TH2F*)gROOT->Get(rowhist))->GetYaxis()->GetFirst();
1877 rowtimeymax = ((TH2F*)gROOT->Get(rowhist))->GetYaxis()->GetLast();
1878 rowtimezmin = ((TH2F*)gROOT->Get(rowhist))->GetMinimum();
1879 rowtimezmax = ((TH2F*)gROOT->Get(rowhist))->GetMaximum();
48265b32 1880
fb3305d1 1881 profrowxmin = ((TH1F*)gROOT->Get(rowhistmax))->GetXaxis()->GetFirst();
1882 profrowxmax = ((TH1F*)gROOT->Get(rowhistmax))->GetXaxis()->GetLast();
1883 profrowymin = ((TH1F*)gROOT->Get(rowhistmax))->GetMinimum();
1884 profrowymax = ((TH1F*)gROOT->Get(rowhistmax))->GetMaximum();
48265b32 1885
ca7b8371 1886 profxxmin = ((TH1F*)gROOT->Get(rowhistxmax))->GetXaxis()->GetFirst();
1887 profxxmax = ((TH1F*)gROOT->Get(rowhistxmax))->GetXaxis()->GetLast();
1888 profxymin = ((TH1F*)gROOT->Get(rowhistxmax))->GetMinimum();
1889 profxymax = ((TH1F*)gROOT->Get(rowhistxmax))->GetMaximum();
48265b32 1890
1891 setrange =1;
1892
1893 delete gROOT->Get(rowhist);
ca7b8371 1894 delete gROOT->Get(rowhistmax);
1895 delete gROOT->Get(rowhistsum);
1896 delete gROOT->Get("hxmax");
48265b32 1897 delete gROOT->Get("legrow");
1898 }
1899
1900 // get channel for xy bin -> getRow -> getNrows -> getHw for each Pad in Row -> get channel for each hw -> make proj
1901 Int_t testy = fHistIndex->GetYaxis()->FindBin(y);
1902 Int_t testx = fHistIndex->GetXaxis()->FindBin(x);
1903 Int_t binchannel = (Int_t)fHistIndex->GetCellContent(testx,testy);
1904
1905 if(binchannel>30000) return;
ca7b8371 1906 if(binchannel<=0 ) { crowtime->Update() ; crowmax->Update() ; return ; }
48265b32 1907
1908 // get hwaddress
1909 Int_t hwadd = (Int_t)fHistChannelTime->GetCellContent(binchannel,0);
1910 Int_t row = fMapHand->GetPadRow(hwadd);
1911 Int_t pad = fMapHand->GetPad(hwadd) ;
1912 Int_t numofpads = fMapHand->GetNumofPads(row);
1913
1914 // create histos
ca7b8371 1915 TH2F *hrowtime = new TH2F(rowhist , "" ,numofpads,0,numofpads,GetTimeBins(),0.0,GetTimeBins());
1916 TH1F *hrowmax = new TH1F(rowhistmax , "" ,numofpads,0,numofpads);
1917 TH1F *hxmax = new TH1F(rowhistxmax, "" ,159,0,159 );
48265b32 1918
1919 // Row profile ///////////
1920 if(fVerb) cout << " Number of pads " << numofpads << endl;
1921 for(Int_t padnr = 0; padnr<numofpads;padnr++)
1922 {
1923 Int_t addrinrow = fMapHand->GetPadAddInRow(row,padnr );
1924 Int_t channel = (Int_t)fHistAddrMapIndex->GetBinContent(addrinrow);
1925 if(channel==-1) continue;
1926
ca7b8371 1927 hrowmax->SetBinContent(padnr+1,fHistAddrMaxAdc->GetBinContent(addrinrow));
48265b32 1928 TH1D *hp = fHistChannelTime->ProjectionY("hp",channel,channel);
1929 for(Int_t time = 0;time<GetTimeBins();time++) {
1930
1931 Float_t val = hp->GetBinContent(time);
ca7b8371 1932 hrowtime->SetCellContent(padnr+1,time+1,val);
48265b32 1933 }
1934 }
1935
1936 // X profile /////////////
1937 Double_t xval = 0.0;
1938 Double_t yval = 0.0;
1939 GetXY(xval,yval,numofpads,row,pad);
1940
1941 Int_t padnr = 0;
1942 Int_t hw = 0;
1943 for(Int_t nrow = 0; nrow<159; nrow++)
1944 {
1945 padnr = GetPadAtX(xval,nrow);
1946 if(padnr>=0)
1947 {
1948 hw = fMapHand->GetPadAddInRow(nrow,padnr);
1949 if(fPadMapHw[hw]==-1){ continue ; }
ca7b8371 1950 else { hxmax->SetBinContent(nrow+1,fHistAddrMaxAdc->GetBinContent(hw)) ; }
48265b32 1951 }
1952 }
1953
ca7b8371 1954 cxmax->cd();
1955 Char_t hxtitle[50] ; sprintf(hxtitle,"max adc in pads at x=%5.1f mm",xval);
1956 hxmax->SetTitle(hxtitle);
1957 hxmax->SetXTitle("row");
1958 if(!GetPedestals()) hxmax->SetYTitle("max adc (baseline sub.)");
1959 else hxmax->SetYTitle("max adc ");
1960 hxmax->SetMinimum(0.01);
1961 hxmax->Draw("l");
48265b32 1962
1963 if(setrange)
1964 {
ca7b8371 1965 hxmax->GetXaxis()->SetRange(profxxmin,profxxmax);
1966 hxmax->SetMinimum(profxymin);
1967 hxmax->SetMaximum(profxymax);
48265b32 1968 }
1969
ca7b8371 1970 cxmax->Update();
48265b32 1971
ca7b8371 1972 crowtime->cd();
48265b32 1973 Char_t title[256];
ca7b8371 1974 Char_t titlemax[256];
1975 if(rocid==1) {sprintf(title,"%s Row=%d",((TH2*)select)->GetTitle(),row) ; sprintf(titlemax,"IROC max/sum Row=%d",row );}
1976 else {sprintf(title,"%s Row=%d",((TH2*)select)->GetTitle(),row-63); sprintf(titlemax,"OROC max/sum Row=%d",row-63);}
48265b32 1977 if(fVerb) cout << " set name " << endl;
1978
1979
1980 // row vs time
ca7b8371 1981 crowtime->cd();
1982 hrowtime->SetTitleSize(0.04);
1983 hrowtime->SetTitle(title);
1984 hrowtime->SetYTitle("timbin");
1985 hrowtime->SetXTitle("pad in row");
1986 hrowtime->SetZTitle("signal (ADC)");
48265b32 1987
ca7b8371 1988 hrowtime->GetXaxis()->SetTitleColor(1);
1989 hrowtime->SetMaximum(1000.0);
1990 hrowtime->SetMinimum(0.0);
48265b32 1991
1992 if(setrange)
1993 {
ca7b8371 1994 hrowtime->GetXaxis()->SetRange(rowtimexmin,rowtimexmax);
1995 hrowtime->GetYaxis()->SetRange(rowtimeymin,rowtimeymax);
1996 hrowtime->SetMinimum(rowtimezmin);
1997 hrowtime->SetMaximum(rowtimezmax);
48265b32 1998 }
1999
ca7b8371 2000 hrowtime->Draw("COLZ");
2001 crowtime->UseCurrentStyle();
2002 crowtime->Update();
48265b32 2003
2004 // max and sum /////////////////////////
ca7b8371 2005 crowmax->cd();
48265b32 2006 if(setrange) {
fb3305d1 2007 hrowmax->GetXaxis()->SetRange(profrowxmin,profrowxmax);
2008 hrowmax->SetMinimum(profrowymin);
2009 hrowmax->SetMaximum(profrowymax);
48265b32 2010 }
ca7b8371 2011 hrowmax->SetTitleSize(0.04);
2012 hrowmax->SetTitle(title);
2013 hrowmax->SetYTitle("max adc");
2014 hrowmax->SetXTitle("pad in row");
2015 hrowmax->GetXaxis()->SetTitleColor(1);
48265b32 2016
ca7b8371 2017 hrowmax->SetLineColor(2);
2018 hrowmax->Draw("l");
2019 crowmax->Update();
48265b32 2020
2021 return;
2022}
2023
2024//__________________________________________________________________
2025void AliTPCMonitor::Write10bitChannel()
2026{
2027
2028 // Write 10 bit words form histogram for active(last pointed) channel
2029
2030 if(fPadUsedHwAddr==-1){ AliWarning(" No active pad "); return ;}
2031
2032 Int_t pad = (Int_t)fMapHand->GetPad( fPadUsedHwAddr);
2033 Int_t row = (Int_t)fMapHand->GetPadRow(fPadUsedHwAddr);
2034 Int_t channel = (Int_t)fPadMapHw[fPadUsedHwAddr];
2035
ca7b8371 2036 Char_t filenameroot[256];
2037 Char_t filenamedat[256];
48265b32 2038 Char_t projhist[256];
2039
2040 if(fPadUsedRoc==1) { sprintf(projhist,"ProjectionOROC"); }
2041 if(fPadUsedRoc==0) { sprintf(projhist,"ProjectionIROC"); }
2042
ca7b8371 2043 sprintf(filenamedat, "Channel_Run%05i_EventID_%i_Pad_%i_Row_%i.dat" ,fRunId,fEventNumber,pad,row);
2044 sprintf(filenameroot,"Channel_Run%05i_EventID_%i_Pad_%i_Row_%i.root" ,fRunId,fEventNumber,pad,row);
48265b32 2045
2046 TH1D* hpr = 0;
ca7b8371 2047 if((hpr=(TH1D*)gROOT->Get(projhist)))
48265b32 2048 {
2049 // root histo
ca7b8371 2050 TFile f(filenameroot,"recreate");
48265b32 2051 hpr->Write();
2052 f.Close();
2053
2054 // raw singal
ca7b8371 2055 ofstream datout(filenamedat,ios::out);
48265b32 2056 datout <<"Timebin \t ADC value " << endl;
2057 for(Int_t i = 1; i <GetTimeBins(); i++)
2058 {
2059 datout << i << " \t \t " << fPad[channel][i] << endl;
2060 }
2061 datout.close();
2062 }
2063 else
2064 {
2065 AliWarning("No projection histo found ");
2066 }
2067}
2068
2069//__________________________________________________________________
2070void AliTPCMonitor::ExecTransform()
2071{
2072
2073 // Make Fast Fourier Transformation for active pad
2074 // fft is only performed for a data sample of size 2^n
2075 // reduce window according to largest power of 2 which is smaller than the viewing range
2076
2077 Char_t namecanv[256];
2078 Char_t projhist[256];
ca7b8371 2079 Char_t namehtrimag[256];
2080 Char_t namehtrreal[256];
48265b32 2081
2082 if(fPadUsedRoc==1) { sprintf(namecanv,"coroc_ch_trans") ; sprintf(projhist,"ProjectionOROC"); }
2083 if(fPadUsedRoc==0) { sprintf(namecanv,"ciroc_ch_trans") ; sprintf(projhist,"ProjectionIROC"); }
2084
2085 TH1D* hproj = 0;
2086
2087 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 ;}
2088 else hproj = (TH1D*)gROOT->Get(projhist) ;
2089
2090
ca7b8371 2091 if(fPadUsedRoc==1) { sprintf(namehtrimag,"htransimagfreq_oroc"); sprintf(namehtrreal,"htransrealfreq_oroc"); }
2092 else { sprintf(namehtrimag,"htransimagfreq_iroc"); sprintf(namehtrreal,"htransrealfreq_iroc"); }
48265b32 2093
ca7b8371 2094 if( gROOT->Get(namehtrimag)) delete gROOT->Get(namehtrimag);
2095 if( gROOT->Get(namehtrreal)) delete gROOT->Get(namehtrreal);
48265b32 2096
2097 TCanvas *ctrans = 0;
2098 if(!(ctrans = (TCanvas*)gROOT->GetListOfCanvases()->FindObject(namecanv)))
2099 {
2100 ctrans = CreateCanvas(namecanv);
2101 ctrans->Divide(1,2);
2102 }
2103
ca7b8371 2104 Int_t binfirst = hproj->GetXaxis()->GetFirst();
2105 Int_t binlast = hproj->GetXaxis()->GetLast();
2106 Int_t bins = binlast -binfirst +1;
48265b32 2107
2108 Int_t power = 0;
2109 for(Int_t pot = 0; pot<=10 ; pot++)
2110 {
2111 Int_t comp = (Int_t)TMath::Power(2,pot);
2112 if(bins>=comp)power = pot;
2113 }
2114
2115 bins = (Int_t)TMath::Power(2,power);
2116
2117 // sampling frequency ;
ca7b8371 2118 Double_t deltat = 1.0/(Float_t)GetSamplingFrequency();
48265b32 2119
2120 // output histo
ca7b8371 2121 TH1D* htransrealfreq = new TH1D(namehtrreal,namehtrreal,10000,-1/(2*deltat),1/(2*deltat));
2122 TH1D* htransimagfreq = new TH1D(namehtrimag,namehtrimag,10000,-1/(2*deltat),1/(2*deltat));
48265b32 2123
2124
ca7b8371 2125 Char_t titlereal[256];
2126 Char_t titleimag[256];
2127 if(fPadUsedRoc==1) { sprintf(titlereal,"OROC DFT real part"); sprintf(titleimag,"OROC DFT imag part"); }
2128 else { sprintf(titlereal,"IROC DFT real part"); sprintf(titleimag,"IROC DFT imag part"); }
48265b32 2129
ca7b8371 2130 htransrealfreq->SetTitle(titlereal); htransrealfreq->SetXTitle("f/hz"); htransrealfreq->SetYTitle("z_{real}(f)");
2131 htransimagfreq->SetTitle(titleimag); htransimagfreq->SetXTitle("f/hz"); htransimagfreq->SetYTitle("z_{imag}(f)");
48265b32 2132
2133
2134 // create complex packed data array
ca7b8371 2135 const Int_t kdatasiz = 2*bins;
2136 Double_t* data = new Double_t[kdatasiz];
48265b32 2137 for(Int_t i=0;i<2*bins;i++) { data[i] = 0.0;}
ca7b8371 2138 for(Int_t i=0;i<bins;i++) { data[2*i] = (Double_t)hproj->GetBinContent(binfirst+i); }
48265b32 2139
2140 // make fourier transformation
2141 AliTPCMonitorFFT* four = new AliTPCMonitorFFT();
2142 four->ComplexRadix2ForwardWrap(data,1,bins);
2143
2144 // write output and fill histos forward
2145 Double_t freq = 0.0;
2146 for(Int_t i=0;i<2*bins;i++)
2147 {
2148 if(i<bins)
2149 {
ca7b8371 2150 if(i<(bins/2)) { freq = i/(bins*deltat) ; }
2151 else { freq = -1*((bins-i)/(bins*deltat)); }
2152 htransrealfreq->Fill( freq,data[2*i] );
2153 htransimagfreq->Fill( freq,data[2*i+1]);
48265b32 2154
2155
2156 }
2157 }
2158
2159 ctrans->cd(1);
ca7b8371 2160 htransrealfreq->Draw();
48265b32 2161 ctrans->cd(2);
ca7b8371 2162 htransimagfreq->Draw();
48265b32 2163 ctrans->Update();
2164 delete four;
2165 delete data;
2166}
2167
2168//__________________________________________________________________
ca7b8371 2169void AliTPCMonitor::ShowSel(Int_t* compval)
48265b32 2170{
2171
2172 // Show only selected components
2173 // First restore original histogram from clone
2174 // Than remove all not matching pads form histos
2175
2176 Int_t connector = 0;
ca7b8371 2177 Int_t fecnr = 0;
fb3305d1 2178 Int_t altrochip = 0;
ca7b8371 2179 Int_t feclocbran = 0;
48265b32 2180 Int_t branch = 0;
2181 Short_t rcuget = 0;
2182 Int_t emptyI = 1;
2183 Int_t index = -1;
2184 Int_t hwadd = 0;
2185
2186 Float_t maxiroc = fHistIROCClone->GetMaximum();
2187 Float_t maxoroc = fHistOROCClone->GetMaximum();
2188
2189
2190 // restore original histos
ca7b8371 2191 for(Int_t row = 0; row<fkNRowsIroc; row++)
48265b32 2192 {
ca7b8371 2193 for(Int_t pad = 0; pad<fkNPadsIroc; pad++)
48265b32 2194 {
2195 index = (Int_t)fHistIROCIndex->GetCellContent(row+1,pad+1);
2196 if(index==-1)continue;
2197 else fHistIROC->SetCellContent(row+1,pad+1,fHistIROCClone->GetCellContent(row+1,pad+1));
2198 }
2199 }
ca7b8371 2200 for(Int_t row = 0; row<fkNRowsOroc; row++)
48265b32 2201 {
ca7b8371 2202 for(Int_t pad = 0; pad<fkNPadsOroc; pad++)
48265b32 2203 {
2204 index = (Int_t)fHistOROCIndex->GetCellContent(row+1,pad+1);
2205 if(index==-1)continue;
2206 else fHistOROC->SetCellContent(row+1,pad+1,fHistOROCClone->GetCellContent(row+1,pad+1));
2207 }
2208 }
2209
2210
2211 // remove not matching entries from fHistIROC/fHistOROC
2212
2213 TH2F* fHist =0;
2214 TH2S* fHistIndex =0;
2215 Int_t npads =0;
2216 Int_t subrows =0;
2217
ca7b8371 2218 for(Int_t row = 0; row< (fkNRowsIroc + fkNRowsOroc); row++)
48265b32 2219 {
ca7b8371 2220 if(row<fkNRowsIroc) { fHist=fHistIROC ; fHistIndex = fHistIROCIndex; npads = fkNPadsIroc; subrows =0 ;}
2221 else { fHist=fHistOROC ; fHistIndex = fHistOROCIndex; npads = fkNPadsOroc; subrows =fkNRowsIroc;}
48265b32 2222
2223 for(Int_t pad = 0; pad<npads; pad++)
2224 {
2225 index = (Int_t)fHistIndex->GetCellContent(row -subrows +1,pad+1);
2226 if(index==-1) continue ;
2227 hwadd = (Int_t)fHistChannelTime->GetCellContent(index,0);
2228
2229 // global fecnr
ca7b8371 2230 fecnr = fMapHand->GetFECfromHw(hwadd);
2231 if(compval[0]!=-1 && fecnr!=compval[0]) { fHist->SetCellContent(row-subrows+1,pad+1,0); continue; }
48265b32 2232
2233 // rcu
2234 rcuget = (hwadd & AliTPCMonitorAltro::GetHwMaskRCU())>> 12;
ca7b8371 2235 if(compval[1]!=-1 && rcuget!=compval[1]) { fHist->SetCellContent(row-subrows+1,pad+1,0); continue; }
48265b32 2236
2237 // branch
ca7b8371 2238 branch = fMapHand->U2fGetBranch(fecnr) ;
2239 if(compval[2]!=-1 && branch!=compval[2]) { fHist->SetCellContent(row-subrows+1,pad+1,0); continue; }
48265b32 2240
2241 // local fec
ca7b8371 2242 feclocbran= fMapHand->U2fGetFECinBranch(fecnr) ;
2243 if(compval[3]!=-1 && feclocbran!=compval[3]) { fHist->SetCellContent(row-subrows+1,pad+1,0); continue; }
48265b32 2244
2245 // connector
2246 connector = fMapHand->GetFECconnector(hwadd);
ca7b8371 2247 if(compval[4]!=-1 && connector!=compval[4]) { fHist->SetCellContent(row-subrows+1,pad+1,0); continue; }
48265b32 2248
2249 // Altro chip
ca7b8371 2250 altrochip = fMapHand->GetAltro(hwadd);
2251 if(compval[5]!=-1 && altrochip!=compval[5]) { fHist->SetCellContent(row-subrows+1,pad+1,0); continue; }
48265b32 2252 emptyI =0;
2253 }
2254 }
2255
2256 TCanvas* c1 =0;
2257 TCanvas* c2 =0;
2258 if(gROOT->GetListOfCanvases()->FindObject("ciroc"))
2259 {
2260 c1 = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("ciroc");
2261 c1->cd() ;
2262 fHistIROC->Draw("COLZ");
2263 fHistIROC->SetMaximum(maxiroc);
2264 fHistIROC->SetMinimum(0.0);
2265 c1->Update();
2266 }
2267 if(gROOT->GetListOfCanvases()->FindObject("coroc"))
2268 {
2269 c2 = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("coroc");
2270 c2->cd() ;
2271 fHistOROC->Draw("COLZ");
2272 fHistOROC->SetMaximum(maxoroc);
2273 fHistOROC->SetMinimum(0.0);
2274 c2->Update();
2275 }
2276 return ;
2277}
2278
2279//__________________________________________________________________
2280void AliTPCMonitor::ResizeCanv()
2281{
2282 // Resize canvases and delete some of them
2283
2284 Char_t carry1[100];
2285 sprintf(carry1,".x %s/TPC/AliTPCMonitorExec.C(1)",gSystem->Getenv("ALICE_ROOT"));
2286 Char_t carry3[100];
2287 sprintf(carry3,".x %s/TPC/AliTPCMonitorExec.C(2)",gSystem->Getenv("ALICE_ROOT"));
2288 if(fVerb) cout << " canv 1 " << endl;
2289
2290 if(gROOT->GetListOfCanvases()->FindObject( "coroc_ch")) { delete gROOT->GetListOfCanvases()->FindObject("coroc_ch") ; }
2291 if(gROOT->GetListOfCanvases()->FindObject( "ciroc_ch")) { delete gROOT->GetListOfCanvases()->FindObject("ciroc_ch") ; }
2292
2293 // for 2dim plots delete create and draw again
2294 if(gROOT->GetListOfCanvases()->FindObject("ciroc"))
2295 {
2296 delete gROOT->GetListOfCanvases()->FindObject("ciroc");
2297 TCanvas* ciroc = CreateCanvas("ciroc");
2298 ciroc->cd();
2299 fHistIROC->Draw("COLZ");
2300 ciroc->AddExec("pad",carry1);
2301 ciroc->AddExec("row",carry3);
2302 fExecPlaneMax=1;
2303 ciroc->Update();
2304 }
2305 // for 2dim plots delete create and draw again
2306 if(gROOT->GetListOfCanvases()->FindObject("coroc"))
2307 {
2308 delete gROOT->GetListOfCanvases()->FindObject("coroc");
2309 TCanvas* coroc = CreateCanvas("coroc");
2310 coroc->cd();
2311 fHistOROC->Draw("COLZ");
2312
2313 coroc->AddExec("pad",carry1);
2314 coroc->AddExec("row",carry3);
2315 coroc->Update();
2316 fExecPlaneMax=1;
2317 }
2318
2319 if(gROOT->GetListOfCanvases()->FindObject( "cbasemean")) { delete gROOT->GetListOfCanvases()->FindObject("cbasemean"); }
2320 if(gROOT->GetListOfCanvases()->FindObject( "cbase")) { delete gROOT->GetListOfCanvases()->FindObject("cbase");}
2321 if(gROOT->GetListOfCanvases()->FindObject( "cbaserms")) { delete gROOT->GetListOfCanvases()->FindObject("cbaserms"); }
2322 if(gROOT->GetListOfCanvases()->FindObject( "cmax")) { delete gROOT->GetListOfCanvases()->FindObject("cmax"); }
2323 if(gROOT->GetListOfCanvases()->FindObject( "csum")) { delete gROOT->GetListOfCanvases()->FindObject("csum"); }
2324 if(gROOT->GetListOfCanvases()->FindObject( "ciroc_ch_trans")) { delete gROOT->GetListOfCanvases()->FindObject("ciroc_ch_trans");}
2325 if(gROOT->GetListOfCanvases()->FindObject( "coroc_ch_trans")) { delete gROOT->GetListOfCanvases()->FindObject("coroc_ch_trans");}
ca7b8371 2326 if(gROOT->GetListOfCanvases()->FindObject( "crowtime")) { delete gROOT->GetListOfCanvases()->FindObject("crowtime"); }
2327 if(gROOT->GetListOfCanvases()->FindObject( "crowmax")) { delete gROOT->GetListOfCanvases()->FindObject("crowmax"); }
2328 if(gROOT->GetListOfCanvases()->FindObject( "cxmax")) { delete gROOT->GetListOfCanvases()->FindObject("cxmax"); }
48265b32 2329 if(gROOT->GetListOfCanvases()->FindObject( "crmsoroc")) { delete gROOT->GetListOfCanvases()->FindObject("crmsoroc"); fExecPadOrocRms = 0; }
2330 if(gROOT->GetListOfCanvases()->FindObject( "crmsiroc")) { delete gROOT->GetListOfCanvases()->FindObject("crmsiroc"); fExecPadIrocRms = 0; }
ca7b8371 2331 if(gROOT->GetListOfCanvases()->FindObject( "crowmax")) { delete gROOT->GetListOfCanvases()->FindObject("crowmax"); }
2332 if(gROOT->GetListOfCanvases()->FindObject( "crowmax")) { delete gROOT->GetListOfCanvases()->FindObject("crowmax"); }
48265b32 2333
2334}
2335
2336
2337
2338
2339//__________________________________________________________________
2340Int_t AliTPCMonitor::ExecProcess()
2341{
2342 // Executable for global Histogram
2343 // Will be called from /TPC/AliTPCMonitorExec.C(3)
2344 // Call ProcessEvent for same event and sector pointed at
2345
2346 Int_t side = 0;
2347 Int_t sector = 0;
2348
2349 Int_t event = gPad->GetEvent();
2350 if(event != 61) return -1;
2351
2352 TObject *select = gPad->GetSelected();
2353 if(!select) return -1;
2354 if(!select->InheritsFrom("TH2")) {gPad->SetUniqueID(0); return -1; }
2355 if( strcmp(select->GetName(),"hglobal" )==0 || ( strcmp(select->GetName(),"SIDE A" )==0) ) side = 0;
2356 else if( strcmp(select->GetName(),"hglobal2")==0 || ( strcmp(select->GetName(),"SIDE C" )==0) ) side = 1;
2357
2358 // get position
2359 Int_t px = gPad->GetEventX();
2360 Int_t py = gPad->GetEventY();
2361 Float_t upy = gPad->AbsPixeltoY(py);
2362 Float_t upx = gPad->AbsPixeltoX(px);
2363 Float_t y = gPad->PadtoY(upy);
2364 Float_t x = gPad->PadtoX(upx);
2365
2366 Int_t testy = ((TH2*)select)->GetYaxis()->FindBin(y);
2367 Int_t testx = ((TH2*)select)->GetXaxis()->FindBin(x);
2368 if(((TH2*)select)->GetCellContent(testx,testy)==0) return -1 ;
2369
2370 Float_t alpha = 0.0;
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 if(x<0.0 && y < 0.0) alpha = TMath::Abs(TMath::ATan(TMath::Abs(x/y)));
2374 if(x<0.0 && y > 0.0) alpha = TMath::Abs(TMath::ATan(TMath::Abs(y/x)));
2375
2376 if(x>0.0 && y < 0.0) alpha += ( TMath::Pi()/2);
2377 if(x<0.0 && y < 0.0) alpha += ( TMath::Pi());
2378 if(x<0.0 && y > 0.0) alpha += (1.5*TMath::Pi());
2379
2380 sector = (Int_t)(alpha/(2*TMath::Pi()/18.0));
2381 if(alpha> (sector+0.5)*(2*TMath::Pi()/18.0)) sector+=1;
2382
2383 if(sector==18 && side ==0 ) {
2384 AliWarning("There was a wromg assignment of sector 0 with sector 18. Check sectors");
2385 sector =0;
2386 }
2387
2388 sector = (18-sector +4)%18;
2389 SetLastSector(sector+ side*18);
2390 SetProcNextEvent(0);
2391
2392 if(fVerb) cout << "AliTPCMonitor::ExecProcess() next side " << side << " next sector " << sector << endl;
2393
2394 return (Int_t)ProcessEvent();
2395
2396}
2397
2398//__________________________________________________________________
fb3305d1 2399Int_t AliTPCMonitor::GetRCUPatch(Int_t runid, Int_t eqid) const
48265b32 2400{
2401
2402 // Return RCU patch index for given equipment id eqid
2403 Int_t patch = 0;
2404 //if(runid>=704)
2405 if(runid>=0)
2406 {
2407 if(eqid>=1000) return 0;
2408 patch = fMapEqidsRcu[eqid] ;
2409 }
2410 else
2411 {
2412 if(eqid==408) {patch = 13*6+4 +0; }
2413 if(eqid==409) {patch = 13*6+5 +0; }
2414 if(eqid==509) {patch = 13*6+0 +0; }
2415 if(eqid==512) {patch = 13*6+3 +0; }
2416 if(eqid==513) {patch = 13*6+1 +0; }
2417 if(eqid==517) {patch = 13*6+2 +0; }
2418
2419 if(eqid==404) {patch = 4*6+5 +0; }
2420 if(eqid==504) {patch = 4*6+4 +0; }
2421 if(eqid==407) {patch = 4*6+3 +0; }
2422 if(eqid==503) {patch = 4*6+2 +0; }
2423 if(eqid==508) {patch = 4*6+1 +0; }
2424 if(eqid==506) {patch = 4*6+0 +0; }
2425 }
2426 return patch;
2427}
2428
2429//__________________________________________________________________
ca7b8371 2430void AliTPCMonitor::DumpHeader(AliRawReaderRoot * fReaderROOT) const
48265b32 2431{
2432 // Dump Event header for ROOT format
2433
2434 cout << "EventHeader : fReaderROOT->GetEquipmentSize() :" << fReaderROOT->GetEquipmentSize() << endl;
2435 cout << "EventHeader : fReaderROOT->GetType() :" << fReaderROOT->GetType() << endl;
2436 cout << "EventHeader : fReaderROOT->GetRunNumber() :" << fReaderROOT->GetRunNumber() << endl;
2437 cout << "EventHeader : fReaderROOT->GetEventId() :" << *(fReaderROOT->GetEventId()) << endl;
2438 cout << "EventHeader : fReaderROOT->GetLDCId() :" << fReaderROOT->GetLDCId() << endl;
2439 cout << "EventHeader : fReaderROOT->GetGDCId() :" << fReaderROOT->GetGDCId() << endl;
2440}
2441
2442//__________________________________________________________________
ca7b8371 2443void AliTPCMonitor::DumpHeader(AliTPCMonitorDateFormat* dateform) const
48265b32 2444{
2445 // Dump Event header for DATE format
2446
ca7b8371 2447 cout << "EquipmentHeader : dateform->GetEquipmentSize() :" << dateform->GetEquipmentSize() << endl;
2448 cout << "EquipmentHeader : dateform->GetEquipmentType() :" << dateform->GetEquipmentType() << endl;
2449 cout << "EquipmentHeader : dateform->GetEquipmentID() :" << dateform->GetEquipmentID() << endl;
2450 cout << "EquipmentHeader : dateform->GetEquipmentTypeAttribute() :" << dateform->GetEquipmentTypeAttribute() << endl;
2451 cout << "EquipmentHeader : dateform->GetEquipmentBasicSize() :" << dateform->GetEquipmentBasicSize() << endl;
2452 cout << "EquipmentHeader : dateform->GetEquipmentHeaderSize() :" << dateform->GetEquipmentHeaderSize() << endl;
2453 cout << "EquipmentHeader : dateform->IsLastSubEventHeader() :" << dateform->IsLastSubEventHeader() << endl;
48265b32 2454}
2455
2456//__________________________________________________________________
2457Double_t AliTPCMonitor::Gamma4(Double_t* x, Double_t* par) {
2458
2459 // Gamma4 function used to fit signals
2460 // Defined in sections: diverging branch set to 0
2461
2462 Double_t val = 0.0;
2463 if(x[0] > par[1])
2464 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];
2465 else
2466 val = 0;
2467 return val;
2468}
2469
2470//__________________________________________________________________
2471TCanvas* AliTPCMonitor::CreateCanvas(Char_t* name)
2472{
2473 // Create Canvases
2474
2475 TCanvas* canv =0;
2476
2477 Int_t xoffset = GetCanvasXOffset();
2478 Int_t xsize = GetCanvasXSize();
2479 Int_t ysize = GetCanvasYSize();
2480 Int_t xspace = GetCanvasXSpace();
2481 Int_t yspace = GetCanvasYSpace();
2482
2483 // ROC 2dim max distribution
2484 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; }
2485 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; }
2486 // ROC 2dim rms distribution
2487 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; }
2488 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; }
2489 // Global ADC max Histos
2490 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; }
2491 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; }
2492 // 1 dim max sum basekine distribution
2493 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; }
2494 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; }
2495 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; }
2496 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; }
2497 // Projections of single channel
2498 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; }
2499 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; }
2500 // FFT for single channel
2501 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; }
2502 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; }
2503 // row profile histograms
ca7b8371 2504 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; }
2505 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; }
2506 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 2507 else { cout << " Warning Canvas name unknown " << endl; return 0 ; }
2508}
2509
2510//__________________________________________________________________
2511void AliTPCMonitor::WriteHistos()
2512{
2513 // Writes all available histograms to a file in current directory
2514 // File name will be specified by : sector, side, runid and eventnumber
2515
2516 if(GetEventProcessed())
2517 {
2518 AliInfo("Write histos to file");
2519 Char_t name[256];
2520 sprintf(name,"SIDE_%i_SECTOR_%02i_RUN_%05i_EventID_%06i.root",(GetLastSector()/18),(GetLastSector()%18),fRunId,fEventNumber);
2521 TFile* f = new TFile(name,"recreate");
2522 for(Int_t i =0; i<fHistList->GetEntries(); i++)
2523 {
2524 if(((TH1*)fHistList->At(i))!=0)
2525 {
2526 ((TH1*)fHistList->At(i))->Write();
2527 }
2528 }
2529 f->ls();
2530 f->Close();
2531 }
2532 else
2533 {
2534 AliError("No Event Processed : Chose Format , File and push 'Next Event' ");
2535 }
2536}
2537
2538
2539//__________________________________________________________________
2540TH1* AliTPCMonitor::GetHisto(char* histname)
2541{
2542
2543 // Returns histogram specified by histname
2544 // check available names for histos in CreateHistos()
2545
2546 TH1* hist = 0;
2547 if((TH1*)fHistList->FindObject(histname))
2548 {
2549 hist = (TH1*)fHistList->FindObject(histname);
2550 }
ca7b8371 2551 else
48265b32 2552 {
2553 cout << " AliTPCMonitor::GetHisto :: Can not find histo with name " << histname << endl;
2554 }
2555 return hist ;
2556}