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