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