1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
18 Revision 1.3 2007/10/12 13:36:27 cvetan
19 Coding convention fixes from Stefan
21 Revision 1.2 2007/09/18 09:44:45 cvetan
22 Sorting out some issues concerning the compilation with and without DATE support
24 Revision 1.1 2007/09/17 10:23:31 cvetan
25 New TPC monitoring package from Stefan Kniege. The monitoring package can be started by running TPCMonitor.C macro located in macros folder.
29 ////////////////////////////////////////////////////////////////////////
31 //// AliTPCMonitor class
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
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.
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.
45 //// Author: Stefan Kniege, IKF, Frankfurt
46 //// Jens Wiechula, Uni Tuebingen (Jens.Wiechula@cern.ch)
48 /////////////////////////////////////////////////////////////////////////
53 #include "AliTPCMonitor.h"
54 #include "AliTPCMonitorMappingHandler.h"
55 #include "AliTPCMonitorFFT.h"
56 #include "AliRawReader.h"
57 #include "AliRawReaderDateOnline.h"
58 #include "AliRawReaderRoot.h"
59 #include "AliRawEventHeaderBase.h"
60 #include "AliAltroRawStreamV3.h"
68 #include "TDirectory.h"
71 #include "TPaveText.h"
73 #include <Riostream.h>
75 ClassImp(AliTPCMonitor)
77 const Int_t AliTPCMonitor::fgkHwMaskFEC = 0x0780;
78 const Int_t AliTPCMonitor::fgkHwMaskBranch = 0x0800;
79 const Int_t AliTPCMonitor::fgkHwMaskFECChannel = 0x007f;
80 const Int_t AliTPCMonitor::fgkHwMaskAltroChannel = 0x000f;
81 const Int_t AliTPCMonitor::fgkHwMaskAltroChip = 0x0070;
82 const Int_t AliTPCMonitor::fgkHwMaskRCU = 0x7000;
84 //____________________________________________________________________________
85 AliTPCMonitor::AliTPCMonitor(const char* name, const char* title) :
86 AliTPCMonitorConfig(name,title),
87 fPad(new Int_t*[GetMaxHwAddr()]),
88 fPadMapHw(new Float_t[GetMaxHwAddr()]),
89 fPadMapRCU(new Int_t*[GetMaxHwAddr()]),
105 fHistAddrMapIndex(0),
107 fHistAddrBaseMean(0),
111 fHistDistrSumIROC(0),
112 fHistDistrMaxIROC(0),
113 fHistDistrSumOROC(0),
114 fHistDistrMaxOROC(0),
115 fHistDistrBase2dIROC(0),
116 fHistDistrBase2dOROC(0),
117 fHistDistrBaseRmsIROC(0),
118 fHistDistrBaseMeanIROC(0),
119 fHistDistrBaseRmsOROC(0),
120 fHistDistrBaseMeanOROC(0),
123 fHistList(new TObjArray()),
150 fMapEqidsSec(new Int_t*[36]),
151 fMapEqidsRcu(new Int_t[1000]),
159 fMonTableChanged(kFALSE)
164 for(Int_t i = 0; i<GetMaxHwAddr(); i++) { fPad[i] = new Int_t[GetTimeBins()];}
165 for(Int_t i = 0; i<GetMaxHwAddr(); i++) { fPadMapRCU[i] = new Int_t[6];}
166 for(Int_t i = 0; i<36; i++) { fMapEqidsSec[i] = new Int_t[6];}
170 if (!gDirectory->GetList())
172 Warning("Build","Current directory is not a valid directory");
175 AliTPCMonitor *hold = (AliTPCMonitor*)gDirectory->GetList()->FindObject(GetName());
178 Warning("Build","Replacing existing histogram: %s (Potential memory leak).",GetName());
179 gDirectory->GetList()->Remove(hold);
181 gDirectory->Append(this);
188 //____________________________________________________________________________
189 AliTPCMonitor::AliTPCMonitor(const AliTPCMonitor &monitor):
190 AliTPCMonitorConfig(monitor.GetName(),monitor.GetTitle()),
191 fPad(new Int_t*[GetMaxHwAddr()]),
192 fPadMapHw(new Float_t[GetMaxHwAddr()]),
193 fPadMapRCU(new Int_t*[GetMaxHwAddr()]),
209 fHistAddrMapIndex(0),
211 fHistAddrBaseMean(0),
215 fHistDistrSumIROC(0),
216 fHistDistrMaxIROC(0),
217 fHistDistrSumOROC(0),
218 fHistDistrMaxOROC(0),
219 fHistDistrBase2dIROC(0),
220 fHistDistrBase2dOROC(0),
221 fHistDistrBaseRmsIROC(0),
222 fHistDistrBaseMeanIROC(0),
223 fHistDistrBaseRmsOROC(0),
224 fHistDistrBaseMeanOROC(0),
227 fHistList(new TObjArray()),
228 fkNRowsIroc(monitor.fkNRowsIroc),
229 fkNRowsOroc(monitor.fkNRowsOroc),
230 fkNPadsIroc(monitor.fkNPadsIroc),
231 fkNPadsOroc(monitor.fkNPadsOroc),
232 fkNPadMinIroc(monitor.fkNPadMinIroc),
233 fkNPadMinOroc(monitor.fkNPadMinOroc),
234 fkNPadMaxIroc(monitor.fkNPadMaxIroc),
235 fkNPadMaxOroc(monitor.fkNPadMaxOroc),
236 fVerb(monitor.fVerb),
237 fLastEv(monitor.fLastEv),
238 fEventNumber(monitor.fEventNumber),
239 fEventNumberOld(monitor.fEventNumberOld),
240 fDisableFit(monitor.fDisableFit),
241 fExecGlob(monitor.fExecGlob),
242 fExecPlaneMax(monitor.fExecPlaneMax),
243 fExecPadIrocRms(monitor.fExecPadIrocRms),
244 fExecPadOrocRms(monitor.fExecPadOrocRms),
245 fRunId(monitor.fRunId),
246 fEqId(monitor.fEqId),
247 fPadUsedRoc(monitor.fPadUsedRoc),
248 fPadUsedHwAddr(monitor.fPadUsedHwAddr),
249 fGdcId(monitor.fGdcId),
250 fLdcId(monitor.fLdcId),
251 fLdcIdOld(monitor.fLdcIdOld),
252 fMapEqidsSec(new Int_t*[36]),
253 fMapEqidsRcu(new Int_t[1000]),
254 fMirror(monitor.fMirror),
255 fChannelIter(monitor.fChannelIter),
256 fMapHand(monitor.fMapHand),
257 fRawReader(monitor.fRawReader),
261 fMonTableChanged(kFALSE)
265 fHistIROC=(TH2F*)monitor.fHistIROC->Clone(); fHistList->Add(fHistIROC);
266 fHistOROC=(TH2F*)monitor.fHistOROC->Clone(); fHistList->Add(fHistOROC);
267 fHistIROCIndex=(TH2S*)monitor.fHistIROCIndex->Clone(); fHistList->Add(fHistIROCIndex);
268 fHistOROCIndex=(TH2S*)monitor.fHistOROCIndex->Clone(); fHistList->Add(fHistOROCIndex);
269 fHistIROCTime=(TH2F*)monitor.fHistIROCTime->Clone(); fHistList->Add(fHistIROCTime);
270 fHistOROCTime=(TH2F*)monitor.fHistOROCTime->Clone(); fHistList->Add(fHistOROCTime);
271 fHistIROCClone=(TH2F*)monitor.fHistIROCClone->Clone(); fHistList->Add(fHistIROCClone);
272 fHistOROCClone=(TH2F*)monitor.fHistOROCClone->Clone(); fHistList->Add(fHistOROCClone);
273 fHistIROCRMS=(TH2F*)monitor.fHistIROCRMS->Clone(); fHistList->Add(fHistIROCRMS);
274 fHistOROCRMS=(TH2F*)monitor.fHistOROCRMS->Clone(); fHistList->Add(fHistOROCRMS);
275 fHistIROCBASE=(TH2F*)monitor.fHistIROCBASE->Clone(); fHistList->Add(fHistIROCBASE);
276 fHistOROCBASE=(TH2F*)monitor.fHistOROCBASE->Clone(); fHistList->Add(fHistOROCBASE);
277 fHistIROCSUM=(TH2F*)monitor.fHistIROCSUM->Clone(); fHistList->Add(fHistIROCSUM);
278 fHistOROCSUM=(TH2F*)monitor.fHistOROCSUM->Clone(); fHistList->Add(fHistOROCSUM);
280 fHistChannelTime=(TH2F*)monitor.fHistChannelTime->Clone(); fHistList->Add(fHistChannelTime);
282 fHistAddrMapIndex=(TH1F*)monitor.fHistAddrMapIndex->Clone(); fHistList->Add(fHistAddrMapIndex);
283 fHistAddrMaxAdc=(TH1F*)monitor.fHistAddrMaxAdc->Clone(); fHistList->Add(fHistAddrMaxAdc);
284 fHistAddrBaseMean=(TH1F*)monitor.fHistAddrBaseMean->Clone(); fHistList->Add(fHistAddrBaseMean);
285 fHistAddrMaxAdcX=(TH1F*)monitor.fHistAddrMaxAdcX->Clone(); fHistList->Add(fHistAddrMaxAdcX);
286 fHistAddrAdcSum=(TH1F*)monitor.fHistAddrAdcSum->Clone(); fHistList->Add(fHistAddrAdcSum);
287 fHistAddrBaseRms=(TH1F*)monitor.fHistAddrBaseRms->Clone(); fHistList->Add(fHistAddrBaseRms);
290 fHistDistrSumIROC=(TH1F*)monitor.fHistDistrSumIROC->Clone(); fHistList->Add(fHistDistrSumIROC);
291 fHistDistrMaxIROC=(TH1F*)monitor.fHistDistrMaxIROC->Clone(); fHistList->Add(fHistDistrMaxIROC);
292 fHistDistrSumOROC=(TH1F*)monitor.fHistDistrSumOROC->Clone(); fHistList->Add(fHistDistrSumOROC);
293 fHistDistrMaxOROC=(TH1F*)monitor.fHistDistrMaxOROC->Clone(); fHistList->Add(fHistDistrMaxOROC);
295 fHistDistrBase2dIROC=(TH2F*)monitor.fHistDistrBase2dIROC->Clone(); fHistList->Add(fHistDistrBase2dIROC);
296 fHistDistrBase2dOROC=(TH2F*)monitor.fHistDistrBase2dOROC->Clone(); fHistList->Add(fHistDistrBase2dOROC);
297 fHistDistrBaseRmsIROC=(TH1D*)monitor.fHistDistrBaseRmsIROC->Clone(); fHistList->Add(fHistDistrBaseRmsIROC);
298 fHistDistrBaseMeanIROC=(TH1D*)monitor.fHistDistrBaseMeanIROC->Clone(); fHistList->Add(fHistDistrBaseMeanIROC);
299 fHistDistrBaseRmsOROC=(TH1D*)monitor.fHistDistrBaseRmsOROC->Clone(); fHistList->Add(fHistDistrBaseRmsOROC);
300 fHistDistrBaseMeanOROC=(TH1D*)monitor.fHistDistrBaseMeanOROC->Clone(); fHistList->Add(fHistDistrBaseMeanOROC);
302 fHistGlobalMaxA=(TH2S*)monitor.fHistGlobalMaxA->Clone(); fHistList->Add(fHistGlobalMaxA);
303 fHistGlobalMaxC=(TH2S*)monitor.fHistGlobalMaxC->Clone(); fHistList->Add(fHistGlobalMaxC);
305 // fPad = new Int_t*[monitor.GetMaxHwAddr()];
306 for(Int_t i = 0; i<GetMaxHwAddr(); i++) { fPad[i] = new Int_t[monitor.GetTimeBins()];}
308 //fPadMapRCU = new Int_t*[monitor.GetMaxHwAddr()];
309 for(Int_t i = 0; i<monitor.GetMaxHwAddr(); i++) { fPadMapRCU[i] = new Int_t[6];}
311 //fPadMapHw = new Float_t[monitor.GetMaxHwAddr()];
313 //fMapEqidsRcu = new Int_t[1000];
314 //fMapEqidsSec = new Int_t*[36];
315 for(Int_t i = 0; i<36; i++) { fMapEqidsSec[i] = new Int_t[6];}
320 if (!gDirectory->GetList())
322 Warning("Build","Current directory is not a valid directory");
327 AliTPCMonitor *hold = (AliTPCMonitor*)gDirectory->GetList()->FindObject(monitor.GetName());
330 Warning("Build","Replacing existing histogram: %s (Potential memory leak).",monitor.GetName());
331 gDirectory->GetList()->Remove(hold);
333 gDirectory->Append(this);
339 //____________________________________________________________________________
341 AliTPCMonitor &AliTPCMonitor:: operator= (const AliTPCMonitor& monitor)
343 // assigment operator
346 ((AliTPCMonitorConfig *)this)->operator=(monitor);
347 fkNRowsIroc=monitor.fkNRowsIroc;
348 fkNRowsOroc=monitor.fkNRowsOroc;
349 fkNPadsIroc=monitor.fkNPadsIroc;
350 fkNPadsOroc=monitor.fkNPadsOroc;
351 fkNPadMinIroc=monitor.fkNPadMinIroc;
352 fkNPadMinOroc=monitor.fkNPadMinOroc;
353 fkNPadMaxIroc=monitor.fkNPadMaxIroc;
354 fkNPadMaxOroc=monitor.fkNPadMaxOroc;
356 fLastEv=monitor.fLastEv;
357 fEventNumber=monitor.fEventNumber;
358 fEventNumberOld=monitor.fEventNumberOld;
359 fDisableFit=monitor.fDisableFit;
360 fExecGlob=monitor.fExecGlob;
361 fExecPlaneMax=monitor.fExecPlaneMax;
362 fExecPadIrocRms=monitor.fExecPadIrocRms;
363 fExecPadOrocRms=monitor.fExecPadOrocRms;
364 fRunId=monitor.fRunId;
366 fPadUsedRoc=monitor.fPadUsedRoc;
367 fPadUsedHwAddr=monitor.fPadUsedHwAddr;
368 fGdcId=monitor.fGdcId;
369 fLdcId=monitor.fLdcId;
370 fLdcIdOld=monitor.fLdcIdOld;
371 fMapHand=monitor.fMapHand;
372 fRawReader=monitor.fRawReader;
376 fMonTableChanged=kFALSE;
378 fHistList = new TObjArray();
379 fHistIROC=(TH2F*)monitor.fHistIROC->Clone(); fHistList->Add(fHistIROC);
380 fHistOROC=(TH2F*)monitor.fHistOROC->Clone(); fHistList->Add(fHistOROC);
381 fHistIROCIndex=(TH2S*)monitor.fHistIROCIndex->Clone(); fHistList->Add(fHistIROCIndex);
382 fHistOROCIndex=(TH2S*)monitor.fHistOROCIndex->Clone(); fHistList->Add(fHistOROCIndex);
383 fHistIROCTime=(TH2F*)monitor.fHistIROCTime->Clone(); fHistList->Add(fHistIROCTime);
384 fHistOROCTime=(TH2F*)monitor.fHistOROCTime->Clone(); fHistList->Add(fHistOROCTime);
385 fHistIROCClone=(TH2F*)monitor.fHistIROCClone->Clone(); fHistList->Add(fHistIROCClone);
386 fHistOROCClone=(TH2F*)monitor.fHistOROCClone->Clone(); fHistList->Add(fHistOROCClone);
387 fHistIROCRMS=(TH2F*)monitor.fHistIROCRMS->Clone(); fHistList->Add(fHistIROCRMS);
388 fHistOROCRMS=(TH2F*)monitor.fHistOROCRMS->Clone(); fHistList->Add(fHistOROCRMS);
389 fHistIROCBASE=(TH2F*)monitor.fHistIROCBASE->Clone(); fHistList->Add(fHistIROCBASE);
390 fHistOROCBASE=(TH2F*)monitor.fHistOROCBASE->Clone(); fHistList->Add(fHistOROCBASE);
391 fHistIROCSUM=(TH2F*)monitor.fHistIROCSUM->Clone(); fHistList->Add(fHistIROCSUM);
392 fHistOROCSUM=(TH2F*)monitor.fHistOROCSUM->Clone(); fHistList->Add(fHistOROCSUM);
394 fHistChannelTime=(TH2F*)monitor.fHistChannelTime->Clone(); fHistList->Add(fHistChannelTime);
396 fHistAddrMapIndex=(TH1F*)monitor.fHistAddrMapIndex->Clone(); fHistList->Add(fHistAddrMapIndex);
397 fHistAddrMaxAdc=(TH1F*)monitor.fHistAddrMaxAdc->Clone(); fHistList->Add(fHistAddrMaxAdc);
398 fHistAddrBaseMean=(TH1F*)monitor.fHistAddrBaseMean->Clone(); fHistList->Add(fHistAddrBaseMean);
399 fHistAddrMaxAdcX=(TH1F*)monitor.fHistAddrMaxAdcX->Clone(); fHistList->Add(fHistAddrMaxAdcX);
400 fHistAddrAdcSum=(TH1F*)monitor.fHistAddrAdcSum->Clone(); fHistList->Add(fHistAddrAdcSum);
401 fHistAddrBaseRms=(TH1F*)monitor.fHistAddrBaseRms->Clone(); fHistList->Add(fHistAddrBaseRms);
404 fHistDistrSumIROC=(TH1F*)monitor.fHistDistrSumIROC->Clone(); fHistList->Add(fHistDistrSumIROC);
405 fHistDistrMaxIROC=(TH1F*)monitor.fHistDistrMaxIROC->Clone(); fHistList->Add(fHistDistrMaxIROC);
406 fHistDistrSumOROC=(TH1F*)monitor.fHistDistrSumOROC->Clone(); fHistList->Add(fHistDistrSumOROC);
407 fHistDistrMaxOROC=(TH1F*)monitor.fHistDistrMaxOROC->Clone(); fHistList->Add(fHistDistrMaxOROC);
409 fHistDistrBase2dIROC=(TH2F*)monitor.fHistDistrBase2dIROC->Clone(); fHistList->Add(fHistDistrBase2dIROC);
410 fHistDistrBase2dOROC=(TH2F*)monitor.fHistDistrBase2dOROC->Clone(); fHistList->Add(fHistDistrBase2dOROC);
411 fHistDistrBaseRmsIROC=(TH1D*)monitor.fHistDistrBaseRmsIROC->Clone(); fHistList->Add(fHistDistrBaseRmsIROC);
412 fHistDistrBaseMeanIROC=(TH1D*)monitor.fHistDistrBaseMeanIROC->Clone(); fHistList->Add(fHistDistrBaseMeanIROC);
413 fHistDistrBaseRmsOROC=(TH1D*)monitor.fHistDistrBaseRmsOROC->Clone(); fHistList->Add(fHistDistrBaseRmsOROC);
414 fHistDistrBaseMeanOROC=(TH1D*)monitor.fHistDistrBaseMeanOROC->Clone(); fHistList->Add(fHistDistrBaseMeanOROC);
416 fHistGlobalMaxA=(TH2S*)monitor.fHistGlobalMaxA->Clone(); fHistList->Add(fHistGlobalMaxA);
417 fHistGlobalMaxC=(TH2S*)monitor.fHistGlobalMaxC->Clone(); fHistList->Add(fHistGlobalMaxC);
419 fPad = new Int_t*[monitor.GetMaxHwAddr()];
420 for(Int_t i = 0; i<GetMaxHwAddr(); i++) { fPad[i] = new Int_t[monitor.GetTimeBins()];}
422 fPadMapRCU = new Int_t*[monitor.GetMaxHwAddr()];
423 for(Int_t i = 0; i<monitor.GetMaxHwAddr(); i++) { fPadMapRCU[i] = new Int_t[6];}
425 fPadMapHw = new Float_t[monitor.GetMaxHwAddr()];
427 fMapEqidsRcu = new Int_t[1000];
428 fMapEqidsSec = new Int_t*[36];
429 for(Int_t i = 0; i<36; i++) { fMapEqidsSec[i] = new Int_t[6];}
434 if (!gDirectory->GetList())
436 Warning("Build","Current directory is not a valid directory");
439 AliTPCMonitor *hold = (AliTPCMonitor*)gDirectory->GetList()->FindObject(monitor.GetName());
442 Warning("Build","Replacing existing histogram: %s (Potential memory leak).",monitor.GetName());
443 gDirectory->GetList()->Remove(hold);
445 gDirectory->Append(this);
452 //____________________________________________________________________________
453 AliTPCMonitor::~AliTPCMonitor()
457 for(Int_t i = 0; i<GetMaxHwAddr(); i++) { delete[] fPad[i] ;}
458 for(Int_t i = 0; i<GetMaxHwAddr(); i++) { delete[] fPadMapRCU[i];}
463 //____________________________________________________________________________
464 void AliTPCMonitor::CreateHistos()
466 // Create histograms to be displayed
468 if(fVerb) cout << " create new ones " << endl;
469 fHistIROC = new TH2F("fHistIROC" ,"fHistIROC" ,fkNRowsIroc,0,fkNRowsIroc,fkNPadsIroc, fkNPadMinIroc, fkNPadMaxIroc); fHistList->Add(fHistIROC);
470 fHistOROC = new TH2F("fHistOROC" ,"fHistOROC" ,fkNRowsOroc,0,fkNRowsOroc,fkNPadsOroc, fkNPadMinOroc, fkNPadMaxOroc); fHistList->Add(fHistOROC);
472 fHistIROCIndex = new TH2S("fHistIROCIndex" ,"fHistIROCIndex" ,fkNRowsIroc,0,fkNRowsIroc,fkNPadsIroc, fkNPadMinIroc, fkNPadMaxIroc); fHistList->Add(fHistIROCIndex);
473 fHistOROCIndex = new TH2S("fHistOROCIndex" ,"fHistOROCIndex" ,fkNRowsOroc,0,fkNRowsOroc,fkNPadsOroc, fkNPadMinOroc, fkNPadMaxOroc); fHistList->Add(fHistOROCIndex);
475 fHistIROCTime = new TH2F("fHistIROCTime" ,"fHistIROCTime" ,fkNRowsIroc,0,fkNRowsIroc,fkNPadsIroc, fkNPadMinIroc, fkNPadMaxIroc); fHistList->Add(fHistIROCTime);
476 fHistOROCTime = new TH2F("fHistOROCTime" ,"fHistOROCTime" ,fkNRowsOroc,0,fkNRowsOroc,fkNPadsOroc, fkNPadMinOroc, fkNPadMaxOroc); fHistList->Add(fHistOROCTime);
478 fHistIROCRMS = new TH2F("fHistIROCRMS" ,"fHistIROCRMS" ,fkNRowsIroc,0,fkNRowsIroc,fkNPadsIroc, fkNPadMinIroc, fkNPadMaxIroc); fHistList->Add(fHistIROCRMS);
479 fHistOROCRMS = new TH2F("fHistOROCRMS" ,"fHistOROCRMS" ,fkNRowsOroc,0,fkNRowsOroc,fkNPadsOroc, fkNPadMinOroc, fkNPadMaxOroc); fHistList->Add(fHistOROCRMS);
481 fHistIROCSUM = new TH2F("fHistIROCSUM" ,"fHistIROCSUM" ,fkNRowsIroc,0,fkNRowsIroc,fkNPadsIroc, fkNPadMinIroc, fkNPadMaxIroc); fHistList->Add(fHistIROCSUM);
482 fHistOROCSUM = new TH2F("fHistOROCSUM" ,"fHistOROCSUM" ,fkNRowsOroc,0,fkNRowsOroc,fkNPadsOroc, fkNPadMinOroc, fkNPadMaxOroc); fHistList->Add(fHistOROCSUM);
484 fHistIROCBASE = new TH2F("fHistIROCBASE" ,"fHistIROCBASE" ,fkNRowsIroc,0,fkNRowsIroc,fkNPadsIroc, fkNPadMinIroc, fkNPadMaxIroc); fHistList->Add(fHistIROCBASE);
485 fHistOROCBASE = new TH2F("fHistOROCBASE" ,"fHistOROCBASE" ,fkNRowsOroc,0,fkNRowsOroc,fkNPadsOroc, fkNPadMinOroc, fkNPadMaxOroc); fHistList->Add(fHistOROCBASE);
488 fHistChannelTime = new TH2F("fHistChannelTime" ,"fHistChannelTime" ,GetNumOfChannels(),0,GetNumOfChannels(),GetTimeBins(),0,GetTimeBins());fHistList->Add(fHistChannelTime);
489 fHistAddrMapIndex = new TH1F("fHistAddrMapIndex" ,"fHistAddrMapIndex" ,GetMaxHwAddr() ,0,GetMaxHwAddr()); fHistList->Add(fHistAddrMapIndex);
490 fHistAddrMaxAdc = new TH1F("fHistAddrMaxAdc" ,"fHistAddrMaxAdc" ,GetMaxHwAddr(),0,GetMaxHwAddr()); fHistList->Add(fHistAddrMaxAdc);
491 fHistAddrMaxAdcX = new TH1F("fHistAddrMaxAdcX" ,"fHistAddrMaxAdcX" ,GetMaxHwAddr(),0,GetMaxHwAddr()); fHistList->Add(fHistAddrMaxAdcX);
492 fHistAddrBaseMean = new TH1F("fHistAddrBaseMean" ,"fHistAddrBaseMean" ,GetMaxHwAddr(),0,GetMaxHwAddr()); fHistList->Add(fHistAddrBaseMean);
493 fHistAddrAdcSum = new TH1F("fHistAddrAdcSum" ,"fHistAddrAdcSum" ,GetMaxHwAddr(),0,GetMaxHwAddr()); fHistList->Add(fHistAddrAdcSum);
494 fHistAddrBaseRms = new TH1F("fHistAddrBaseRms" ,"fHistAddrBaseRms" ,GetMaxHwAddr(),0,GetMaxHwAddr()); fHistList->Add(fHistAddrBaseRms);
495 fHistDistrSumIROC = new TH1F("fHistDistrSumIROC" ,"fHistDistrSumIROC" ,400,0.0,4000.0); fHistList->Add(fHistDistrSumIROC);
496 fHistDistrMaxIROC = new TH1F("fHistDistrMaxIROC" ,"fHistDistrMaxIROC" ,500,0.0,1000.0); fHistList->Add(fHistDistrMaxIROC);
497 fHistDistrSumOROC = new TH1F("fHistDistrSumOROC" ,"fHistDistrSumOROC" ,400,0.0,4000.0); fHistList->Add(fHistDistrSumOROC);
498 fHistDistrMaxOROC = new TH1F("fHistDistrMaxOROC" ,"fHistDistrMaxOROC" ,500,0.0,1000.0); fHistList->Add(fHistDistrMaxOROC);
500 fHistDistrBase2dIROC = new TH2F("fHistDistrBase2dIROC" ,"fHistDistrBase2dIROC",100,0.0,100.0,100,0.0,10.0); fHistList->Add(fHistDistrBase2dIROC);
501 fHistDistrBase2dOROC = new TH2F("fHistDistrBase2dOROC" ,"fHistDistrBase2dOROC",100,0.0,100.0,100,0.0,10.0); fHistList->Add(fHistDistrBase2dOROC);
503 fHistGlobalMaxA = new TH2S("SIDE A" ,"SIDE A" ,500,-3000,3000,500,-3000,3000); fHistList->Add(fHistGlobalMaxA);
504 fHistGlobalMaxC = new TH2S("SIDE C" ,"SIDE C" ,500,-3000,3000,500,-3000,3000); fHistList->Add(fHistGlobalMaxC);
508 //____________________________________________________________________________
509 Int_t AliTPCMonitor::ProcessEvent()
512 // Depending on the value of the sector id all sectors (sectorid == -1) are processed.
514 // In this case only the maximum values are calculated per pad and filled to the global histograms
515 // In a second loop the last processed(displayed) sector will be processed (sectorid!=-1)
516 // again and the baseline rms and further quantities are calculated
518 // If only one sector should be processed SetProcOneSector(1) should be set.
519 // In this case only the specified (last/last displayed) sector will be processed.
521 // If GetProcNextEvent()==0 the same event will be processed again
525 Int_t retflag = 0; // id of last sector + 1000, or error flag
526 if(GetProcNextEvent()==1 && fLastEv) { AliInfo("Last event already processed"); }
527 if(GetProcNextEvent()==1) ResetSectorArray();
530 if(GetProcNextEvent()==0 || GetProcOneSector()==1 ) sectorid = GetLastSector();
534 retflag = ReadDataNew(sectorid);
536 SetLastProcFile(GetFile());
538 if(retflag>=10 && retflag<1000){ AliError("Could not read event properly: Check file name and format or try next event"); return 0 ;}
543 if(sectorid==-1 && retflag >1000)
545 AliInfo("Second read cycle");
547 if(GetLastSectorDisplayed()==-1) {sectorid = GetLastSector() ; }
548 else {sectorid = GetLastSectorDisplayed(); SetLastSector(sectorid) ; }
549 retflag = ReadDataNew(sectorid);
552 SetLastSectorDisplayed(sectorid) ;
553 fMapHand->ReadfecHwMap(GetLastSector());
556 SetEventProcessed(1);
559 //__________________________________________________________________
560 Int_t AliTPCMonitor::ReadDataNew(Int_t secid)
562 // Read Data File/Stream for specified Format.
563 // Payload will be extracted from either ROOT or DATE format
564 // and passed to FillHistsDecode for decoding of the adc information
566 if (TString(GetLastProcFile())!=GetFile() || fMonTableChanged) {
572 TString file(GetFile());
573 if (file.BeginsWith("mem://")){
574 file.ReplaceAll("mem://","");
575 fRawReader = new AliRawReaderDateOnline(file.Data(),fkMonTable);
577 fRawReader = AliRawReader::Create(GetFile());
579 SetLastProcFile(GetFile());
583 AliWarning("Coult not initialize raw reader");
588 while(skip && GetProcNextEvent())
590 if(fVerb) cout << "AliTPCMonitor::ReadDataNew get event " << endl;
591 if(fRawReader->IsA()==AliRawReaderRoot::Class()){
592 AliInfo(Form("Root, NextEvent: %d\n",GetEventID()));
593 if (!fRawReader->GotoEvent(GetEventID())){AliError("Could not get next Event"); return 11 ;}
594 } else if(!fRawReader->NextEvent()) { AliError("Could not get next Event"); return 11 ;}
595 // skip all events but physics, calibration and software trigger events!
596 UInt_t eventType=fRawReader->GetType();
597 if ( !(eventType==AliRawEventHeaderBase::kPhysicsEvent ||
598 eventType==AliRawEventHeaderBase::kCalibrationEvent ||
599 eventType==AliRawEventHeaderBase::kSystemSoftwareTriggerEvent ||
600 eventType==AliRawEventHeaderBase::kDetectorSoftwareTriggerEvent) ) {
601 if (fVerb) cout<< "Skipping event! Its neither of 'physics, calibration and software trigger event'" << endl;
602 if(fRawReader->IsA()==AliRawReaderRoot::Class()){
603 if (fEventNumber<fRawReader->GetNumberOfEvents()-1) ++fEventNumber;
604 else {AliError("No more events");return 11;}
609 //test if the TPC has data
611 fRawReader->Select("TPC");
612 Int_t eventNr=fRawReader->GetEventIndex();
613 if (!fRawReader->ReadNextData(data)) {
615 AliInfo(Form("%d / %d",fEventNumber,fRawReader->GetNumberOfEvents()));
616 if(fRawReader->IsA()==AliRawReaderRoot::Class()){
617 if (fEventNumber<fRawReader->GetNumberOfEvents()-1){
619 // printf("inc conter\n");
622 AliError("No more events");
627 fEventNumber = eventNr;
628 fEventNumberOld = eventNr;
631 AliInfo(Form("secid: %d",secid));
633 //========================== Histogram filling ======================
635 AliAltroRawStreamV3 *altro=new AliAltroRawStreamV3(fRawReader);
636 altro->SelectRawData("TPC");
641 Int_t nextHwAddress = 0;
649 while ( altro->NextDDL() ){
650 fGdcId = fRawReader->GetGDCId() ;
651 fLdcId = fRawReader->GetLDCId() ;
652 fRunId = fRawReader->GetRunNumber() ;
653 fEqId = fRawReader->GetEquipmentId();
654 rcupatch = GetRCUPatch(fRunId, fEqId);
655 Int_t rcupatchSector=rcupatch%6;
656 lastrcuid = (rcupatch+1000);
658 Int_t currentSector=rcupatch/6;
660 if(fLdcIdOld!=fLdcId && fChannelIter!=0) {
663 FillGlobal(GetLastSector());
665 if (fVerb) printf("filled sector: %d\n",GetLastSector());
670 // printf("RET: filled sector: %d\n",GetLastSector());
672 // if (rcupatch/6!=secid) continue;
677 if (!CheckEqId(secid,fEqId)) continue;
678 if (fVerb) printf("Sector: %d, RCU patch: %d, LDC: %d, EqId: %d\n",currentSector,rcupatch, fLdcId, fEqId);
680 while ( altro->NextChannel() ){
681 hw=altro->GetHWAddress();
682 nextHwAddress = ( hw + (rcupatchSector<<12) );
683 fPad[fChannelIter][0] = nextHwAddress ;
684 fPadMapHw[nextHwAddress] = fChannelIter ;
686 while ( altro->NextBunch() ){
687 Int_t startTbin = (Int_t)altro->GetStartTimeBin();
688 Int_t bunchlength = (Int_t)altro->GetBunchLength();
689 const UShort_t *sig = altro->GetSignals();
690 for (Int_t iTimeBin = 0; iTimeBin<bunchlength; iTimeBin++){
691 Int_t adc=(Int_t)sig[iTimeBin];
692 Int_t ntime=startTbin-iTimeBin;
693 //fill channel information
694 fPad[fChannelIter][ntime] = adc;
695 if( (adc>maxADC) && (ntime>=GetRangeMaxAdcMin()) && (ntime<GetRangeMaxAdcMax() )) {maxADC = adc;maxx = ntime ;}
696 if( (ntime>=GetRangeSumMin()) && (ntime<GetRangeSumMax() )) {sum+=adc; sumn++;}
700 //get pedestal, noise
701 Float_t pedestal=TMath::Mean(GetRangeBaseMax()-GetRangeBaseMin(),fPad[fChannelIter]+GetRangeBaseMin());
702 Float_t noise =TMath::RMS(GetRangeBaseMax()-GetRangeBaseMin(),fPad[fChannelIter]+GetRangeBaseMin());
703 fHistAddrMaxAdc->SetBinContent(nextHwAddress,maxADC-GetPedestals()*pedestal);
709 fHistDistrBase2dIROC->Fill(pedestal,noise);
710 fHistDistrSumIROC->Fill(sum);
711 fHistDistrMaxIROC->Fill(maxADC-pedestal*GetPedestals());
712 fHistDistrSumIROC->Fill(sum -sumn*pedestal*GetPedestals());
716 fHistDistrBase2dOROC->Fill(pedestal,noise);
717 fHistDistrSumOROC->Fill(sum);
718 fHistDistrMaxOROC->Fill(maxADC-pedestal*GetPedestals());
719 fHistDistrSumOROC->Fill(sum -sumn*pedestal*GetPedestals());
722 fHistAddrAdcSum->SetBinContent( nextHwAddress,sum);
723 fHistAddrMapIndex->SetBinContent(nextHwAddress,fChannelIter);
724 fHistAddrBaseMean->SetBinContent(nextHwAddress,pedestal);
725 fHistAddrMaxAdcX->SetBinContent( nextHwAddress,maxx);
726 fHistAddrBaseRms->SetBinContent( nextHwAddress,noise);
731 SetLastSector(rcupatch/6);
732 if(fChannelIter!=0 && secid==-1 ) SetSectorFilled(rcupatch/6);
736 if(fChannelIter!=0 && secid==-1) { FillGlobal(GetLastSector());}
750 //____________________________________________________________________________
751 void AliTPCMonitor::FillHistsPadPlane()
753 // Fill 2Dim histograms for IROC and OROC (max , rms and sum)
755 if(fVerb)cout << "AliTPCMonitor::FillHistsPadPlane() Start " << endl;
756 if(fVerb)PrintConfig();
763 for(Int_t ch = 0; ch<fChannelIter; ch++)
766 fHistChannelTime->SetCellContent(ch,0,hwadd);
768 for(Int_t bin = 1; bin <GetTimeBins(); bin++)
770 if( fHistChannelTime->GetCellContent(ch,bin)!=0) cout << " cellcontent already set " << endl;
771 if( GetPedestals()==1 ) fHistChannelTime->SetCellContent(ch,bin,(fPad[ch][bin]- fHistAddrBaseMean->GetBinContent(hwadd)));
772 else fHistChannelTime->SetCellContent(ch,bin,(fPad[ch][bin]));
775 pad = fMapHand->GetPad( hwadd);
776 row = fMapHand->GetPadRow(hwadd);
777 padmax = fMapHand->GetNumofPads(row);
781 fHistIROC->SetCellContent( row +1 ,pad +55 -padmax/2 +1,fHistAddrMaxAdc->GetBinContent( hwadd));
782 fHistIROCIndex->SetCellContent(row +1 ,pad +55 -padmax/2 +1,ch);
783 fHistIROCRMS->SetCellContent( row +1 ,pad +55 -padmax/2 +1,fHistAddrBaseRms->GetBinContent( hwadd));
784 fHistIROCBASE->SetCellContent( row +1 ,pad +55 -padmax/2 +1,fHistAddrBaseMean->GetBinContent(hwadd));
785 fHistIROCSUM->SetCellContent( row +1 ,pad +55 -padmax/2 +1,fHistAddrAdcSum->GetBinContent( hwadd));
789 fHistOROC->SetCellContent( row-63 +1 ,pad +70 -padmax/2 +1,fHistAddrMaxAdc->GetBinContent( hwadd));
790 fHistOROCIndex->SetCellContent(row-63 +1 ,pad +70 -padmax/2 +1,ch);
791 fHistOROCRMS->SetCellContent( row-63 +1 ,pad +70 -padmax/2 +1,fHistAddrBaseRms->GetBinContent( hwadd));
792 fHistOROCBASE->SetCellContent( row-63 +1 ,pad +70 -padmax/2 +1,fHistAddrBaseMean->GetBinContent(hwadd));
793 fHistOROCSUM->SetCellContent( row-63 +1 ,pad +70 -padmax/2 +1,fHistAddrAdcSum->GetBinContent( hwadd));
797 fHistChannelTime->GetXaxis()->SetRange(0,fChannelIter);
798 fHistChannelTime->GetYaxis()->SetRange(0,GetTimeBins());
803 //____________________________________________________________________________
804 void AliTPCMonitor::ResetArrays()
807 for(Int_t row = 0 ; row < fkNRowsIroc; row++)
809 for(Int_t pad = 0 ; pad < fkNPadsIroc ; pad++)
811 fHistIROCIndex->SetCellContent(row+1,pad+1,-1);
814 for(Int_t row = 0 ; row < fkNRowsOroc; row++)
816 for(Int_t pad = 0 ; pad < fkNPadsOroc ; pad++)
818 fHistOROCIndex->SetCellContent(row+1,pad+1,-1);
822 for(Int_t ch= 0; ch<GetMaxHwAddr(); ch++)
824 fHistAddrMaxAdcX->SetBinContent(ch,-1);
825 fHistAddrMapIndex->SetBinContent(ch,-1);
826 fHistAddrMaxAdc->SetBinContent( ch, 0);
827 fHistAddrBaseMean->SetBinContent( ch, 0);
828 fHistAddrAdcSum->SetBinContent( ch, 0);
829 fHistAddrBaseRms->SetBinContent(ch, 0);
832 for(Int_t ch = 0; ch< GetNumOfChannels(); ch++)
834 for(Int_t bin = 0; bin< GetTimeBins(); bin++)
839 for(Int_t ch = 0; ch< GetMaxHwAddr(); ch++)
842 fPadMapRCU[ch][0]=-1;
843 fPadMapRCU[ch][1]=-1;
844 fPadMapRCU[ch][2]=-1;
845 fPadMapRCU[ch][3]=-1;
846 fPadMapRCU[ch][4]=-1;
847 fPadMapRCU[ch][5]=-1;
853 //____________________________________________________________________________
854 void AliTPCMonitor::ResetHistos()
857 for(Int_t i =0; i<fHistList->GetEntries(); i++)
859 TString name=fHistList->At(i)->GetName();
860 if(GetProcNextEvent()==0 && (name=="SIDE A" || name=="SIDE C")) continue;
861 ((TH1*)fHistList->At(i))->Reset();
866 //____________________________________________________________________________
867 void AliTPCMonitor::DeleteHistos()
870 for(Int_t i =0; i<fHistList->GetEntries(); i++)
872 delete (TH1*)fHistList->At(i);
877 //__________________________________________________________________
878 Int_t AliTPCMonitor::CheckEqId(Int_t secid,Int_t eqid)
880 // Check if equipment id corresponds to any rcu patch in sector
881 // Equipment ids changed during commisioning in 2006 (starting from run 704)
882 // However Runids started from 0 again in 2007
883 // Now only runids from commissioning in 2006 after runid 704 and all new ones are supported.
884 // Comment in equipment check for runids < 704 if old runs should be processed
886 if(fVerb) cout << "AliTPCMonitor::CheckEqId : SectorId " << secid << " EquipmentId " << eqid << " runid " << fRunId << endl;
888 //skip all eqids which do not belong to the TPC
889 if ( eqid<768||eqid>983 ) return 0;
891 // if(fRunId<704 && 0) // commented out --> runs with runid < 704 in 2006 are not recognized anymore
893 // if( (secid>-1) && (secid<36) ) // if ( secid is in range) { take only specific eqids} else { take all }
895 // if( (secid==13) && ( eqid!=408 && eqid!=409 && eqid!=509 && eqid!=512 && eqid!=513 && eqid!=517 )) {passed=0;}
896 // else if( (secid==4) && ( eqid!=404 && eqid!=504 && eqid!=407 && eqid!=503 && eqid!=508 && eqid!=506 )) {passed=0;}
898 // else {if(fVerb) cout << "passed check "<< endl; }
902 if( (secid>-1) && (secid<36) ) // if ( secid is in range) { take only specific eqids} else { take all }
904 if(eqid!=fMapEqidsSec[secid][0] && eqid!= fMapEqidsSec[secid][1] && eqid!=fMapEqidsSec[secid][2] &&
905 eqid!=fMapEqidsSec[secid][3] && eqid!= fMapEqidsSec[secid][4] && eqid!=fMapEqidsSec[secid][5] ) {passed=0;}
907 else {if(fVerb) cout << "passed check "<< endl;}
913 //__________________________________________________________________
914 void AliTPCMonitor::SetEqIds()
916 // Set mapping for equipment ids
917 for(Int_t i = 0; i<36 ; i++)
919 for(Int_t j = 0; j<6; j++)
921 if(j<2) fMapEqidsSec[i][j]= 768+i*2+j;
922 else fMapEqidsSec[i][j]= 840+i*4+j-2;
926 for(Int_t i = 0; i<36 ; i++)
928 for(Int_t j = 0; j<6; j++)
930 if(j<2) fMapEqidsRcu[768+i*2+j] = i*6 +j;
931 else fMapEqidsRcu[840+i*4+j-2] = i*6 +j;
936 //__________________________________________________________________
937 void AliTPCMonitor::FillGlobal(Int_t sector)
940 // Fill global histograms with max adc for each channel
943 if((sector/18) ==0) hglob = fHistGlobalMaxA;
944 else hglob = fHistGlobalMaxC;
946 Float_t rotsec = (2*TMath::Pi()/18.0);
947 Float_t rot = (-rotsec*(sector%18) +4*rotsec);
949 Float_t m11 = TMath::Cos(rot);
950 Float_t m12 = TMath::Sin(rot);
951 Float_t m21 = -1*TMath::Sin(rot);
952 Float_t m22 = TMath::Cos(rot);
954 Int_t max = 0; // use integer for global view
966 for(Int_t hw = 0; hw<fHistAddrMaxAdc->GetNbinsX(); hw++)
968 max = (Int_t)fHistAddrMaxAdc->GetBinContent(hw);
971 pad = fMapHand->GetPad( hw);
972 row = fMapHand->GetPadRow(hw);
973 if (row==-1) continue;
974 padmax = fMapHand->GetNumofPads(row);
975 if (sector%36>17) fMirror=-1;
977 GetXY(xval ,yval , padmax,row ,pad);
978 xdr = xval*m11 +yval*m12;
979 ydr = xval*m21 +yval*m22;
980 if(hglob->GetBinContent(hglob->GetXaxis()->FindBin(xdr),hglob->GetYaxis()->FindBin(ydr))==0) hglob->Fill(xdr,ydr,(Int_t)max);
986 //__________________________________________________________________
987 void AliTPCMonitor::GetXY( Double_t& xval , Double_t& yval , Int_t padmax, Int_t row , Int_t pad) const
989 // Get x and y position of pad
993 xval = fMirror*( 2*padmax -4*pad -2);
994 yval = 852.25 +7.5*row;
998 xval = fMirror*( 3*padmax -6*pad -3);
999 if((row-63)<63) { yval = 10*(row-63) +1351; }
1000 else { yval = 15*(row-63-64)+1993.5; }
1005 //__________________________________________________________________
1006 Int_t AliTPCMonitor::GetPadAtX(Float_t xval, Int_t row, Int_t padmax) const
1008 // Get pad number at given position in x
1011 if(row<63) {pad = (Int_t)( ( (xval/fMirror) +2 -2*padmax)/-4);}
1012 else {pad = (Int_t)( ( (xval/fMirror) +3 -3*padmax)/-6);}
1014 if(pad>=padmax) return -1;
1019 //__________________________________________________________________
1020 Int_t AliTPCMonitor::GetPadAtX(Float_t xval, Int_t row) const
1023 // Get pad number at given position in x
1025 Int_t padmax = fMapHand->GetNumofPads(row);
1028 if(row<63) {pad = (Int_t)( ( (xval/fMirror) +2 -2*padmax)/-4);}
1029 else {pad = (Int_t)( ( (xval/fMirror) +3 -3*padmax)/-6);}
1031 if(pad>=padmax) return -1;
1036 //__________________________________________________________________
1037 void AliTPCMonitor::DrawHists(Int_t histos)
1040 // Draw sets of histograms
1041 // histos==1 : 2Dim histos for MAX adc and add executables
1042 // histos==2 : distributions max/rms/sum
1043 // histos==3 : global max adc for specified SideA/C
1046 if(fVerb) cout << " Draw histos " << endl;
1048 if(GetLastSector()/18==0 ) cside="A";
1051 TString titleSEC = Form("Sector %i Side %s Run : %05i EventID %i " ,GetLastSector()%18,cside.Data(),fRunId, fEventNumber);
1052 TString titleEvent= Form("Time <-> Channles %s" ,titleSEC.Data());
1053 TString titleIROC = Form("IROC %s" ,titleSEC.Data());
1054 TString titleOROC = Form("OROC %s" ,titleSEC.Data());
1056 TString titleMAX = Form("Max (timebin: %i,%i) %s" ,GetRangeMaxAdcMin(),GetRangeMaxAdcMax(),titleSEC.Data());
1057 TString titleSUM = Form("Sum (timebin: %i,%i) %s" ,GetRangeSumMin() ,GetRangeSumMax() ,titleSEC.Data());
1058 TString titleBASE = Form("Baseline RMS<->Mean (timebin: %i-%i) %s" ,GetRangeBaseMin() ,GetRangeBaseMax() ,titleSEC.Data());
1059 TString titleMEAN = Form("Baseline Mean (timebin: %i-%i) %s" ,GetRangeBaseMin() ,GetRangeBaseMax() ,titleSEC.Data());
1060 TString titleRMS = Form("Baseline RMS (timebin: %i-%i) %s" ,GetRangeBaseMin() ,GetRangeBaseMax() ,titleSEC.Data());
1064 // IROC _______________________________________________________________
1066 ciroc = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("ciroc");
1069 ciroc = CreateCanvas("ciroc");
1074 fHistIROC->SetXTitle("row");
1075 fHistIROC->SetYTitle("pad");
1076 if(GetPedestals()) fHistIROC->SetZTitle("max ADC (baseline sub)");
1077 else fHistIROC->SetZTitle("max ADC ");
1078 fHistIROC->SetTitle(titleIROC.Data());
1079 fHistIROC->SetMinimum(0.01);
1080 fHistIROC->Draw("COLZ");
1081 ciroc->UseCurrentStyle();
1084 fHistIROCTime->SetXTitle("row"); fHistIROCTime->SetZTitle("peak time (fit)"); fHistIROCTime->SetYTitle("pad"); fHistIROCTime->SetTitle(titleIROC.Data());
1085 fHistIROCRMS->SetXTitle("row"); fHistIROCRMS->SetZTitle( "baseline rms (ADC)"); fHistIROCRMS->SetYTitle("pad"); fHistIROCRMS->SetTitle(titleIROC.Data());
1089 coroc =(TCanvas*)gROOT->GetListOfCanvases()->FindObject("coroc");
1091 coroc = CreateCanvas("coroc");
1096 fHistOROC->SetXTitle("row");
1097 fHistOROC->SetYTitle("pad");
1098 if(GetPedestals()) fHistOROC->SetZTitle("max ADC (baseline sub)");
1099 else fHistOROC->SetZTitle("max ADC ");
1100 fHistOROC->SetTitle(titleOROC.Data());
1101 fHistOROC->SetMinimum(0.01);
1102 fHistOROC->Draw("COLZ");
1103 coroc->UseCurrentStyle();
1106 fHistOROCTime->SetXTitle("row"); fHistOROCTime->SetZTitle("peak time (fit) (timebins)"); fHistOROCTime->SetYTitle("pad"); fHistOROCTime->SetTitle(titleOROC.Data());
1107 fHistOROCRMS->SetXTitle("row"); fHistOROCRMS->SetZTitle("baseline rms (ADC)"); fHistOROCRMS->SetYTitle("pad"); fHistOROCRMS->SetTitle(titleOROC.Data());
1110 TString namesum=Form("ADC sum (bins: %i, %i)",GetRangeSumMin() ,GetRangeSumMax() );
1111 fHistIROCSUM->SetXTitle("row");
1112 fHistIROCSUM->SetZTitle(namesum.Data());
1113 fHistIROCSUM->SetYTitle("pad");
1114 fHistIROCSUM->SetTitle(titleIROC.Data());
1116 fHistOROCSUM->SetXTitle("row");
1117 fHistOROCSUM->SetZTitle(namesum);
1118 fHistOROCSUM->SetYTitle("pad");
1119 fHistOROCSUM->SetTitle(titleOROC.Data());
1122 TString namebase=Form("base mean (timbebin: %i, %i )",GetRangeBaseMin(),GetRangeBaseMax());
1123 fHistIROCBASE->SetXTitle("row");
1124 fHistIROCBASE->SetZTitle(namebase.Data());
1125 fHistIROCBASE->SetYTitle("pad");
1126 fHistIROCBASE->SetTitle(titleIROC.Data());
1128 fHistOROCBASE->SetXTitle("row");
1129 fHistOROCBASE->SetZTitle(namebase);
1130 fHistOROCBASE->SetYTitle("pad");
1131 fHistOROCBASE->SetTitle(titleOROC.Data());
1133 if(fHistIROCClone) fHistIROCClone->Delete();
1134 if(fHistOROCClone) fHistOROCClone->Delete();
1135 fHistIROCClone = (TH2F*)fHistIROC->Clone("fHistIROCClone");
1136 fHistOROCClone = (TH2F*)fHistOROC->Clone("fHistOROCClone");
1139 if(fExecPlaneMax==0)
1141 TString carry1=Form(".x %s/TPC/AliTPCMonitorExec.C(1)",gSystem->Getenv("ALICE_ROOT"));
1142 ciroc->AddExec("pad",carry1.Data());
1143 coroc->AddExec("pad",carry1.Data());
1145 TString carry2=Form(".x %s/TPC/AliTPCMonitorExec.C(2)",gSystem->Getenv("ALICE_ROOT"));
1146 ciroc->AddExec("row",carry2.Data());
1147 coroc->AddExec("row",carry2.Data());
1155 // MAX ADC distribution ____________________________________________
1157 cmax = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("cmax");
1158 if(!cmax) cmax = CreateCanvas("cmax");
1161 fHistDistrMaxIROC->GetXaxis()->SetRangeUser(0.0,1000.0);
1162 fHistDistrMaxIROC->SetXTitle("max ADC (ADC)");
1163 fHistDistrMaxIROC->SetYTitle("counts");
1164 fHistDistrMaxIROC->SetTitle(titleMAX.Data());
1165 fHistDistrMaxIROC->Draw("");
1166 fHistDistrMaxOROC->SetLineColor(2);
1167 fHistDistrMaxOROC->Draw("same");
1169 if(fHistDistrMaxOROC->GetMaximum()> fHistDistrMaxIROC->GetMaximum()) fHistDistrMaxIROC->SetMaximum(fHistDistrMaxOROC->GetMaximum()*1.1);
1171 TLegend* legio = new TLegend(0.6,0.6,0.8,0.8);
1172 legio->SetFillColor(0);
1173 legio->AddEntry(fHistDistrMaxIROC,"IROC","l");
1174 legio->AddEntry(fHistDistrMaxOROC,"OROC","l");
1175 legio->Draw("same");
1177 // ADC sum distribution
1179 csum = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("csum");
1180 if(!csum) csum = CreateCanvas("csum") ;
1183 fHistDistrSumIROC->SetXTitle("sum ADC (ADC)");
1184 fHistDistrSumIROC->SetYTitle("counts");
1185 fHistDistrSumIROC->SetTitle(titleSUM.Data());
1186 fHistDistrSumIROC->Draw("");
1187 fHistDistrSumOROC->SetLineColor(2);
1188 fHistDistrSumOROC->Draw("same");
1189 if(fHistDistrSumOROC->GetMaximum()> fHistDistrSumIROC->GetMaximum()) fHistDistrSumIROC->SetMaximum(fHistDistrSumOROC->GetMaximum()*1.1);
1190 legio->Draw("same");
1192 // BASELINE MEAN distribution
1193 TCanvas* cbasemean = 0;
1194 cbasemean = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("cbasemean");
1195 if(!cbasemean) cbasemean = CreateCanvas("cbasemean");
1198 fHistDistrBaseMeanIROC = fHistDistrBase2dIROC->ProjectionX("fHistDistrBaseMeanIROC");
1199 fHistDistrBaseMeanIROC->SetXTitle("base mean (ADC)");
1200 fHistDistrBaseMeanIROC->SetYTitle("counts");
1201 fHistDistrBaseMeanIROC->SetTitle(titleMEAN.Data());
1202 fHistDistrBaseMeanIROC->Draw("");
1204 fHistDistrBaseMeanOROC = fHistDistrBase2dOROC->ProjectionX("fHistDistrBaseMeanOROC");
1205 fHistDistrBaseMeanOROC->SetLineColor(2);
1206 fHistDistrBaseMeanOROC->Draw("same");
1207 if(fHistDistrBaseMeanOROC->GetMaximum()>fHistDistrBaseMeanIROC->GetMaximum()) fHistDistrBaseMeanIROC->SetMaximum(fHistDistrBaseMeanOROC->GetMaximum()*1.1);
1208 legio->Draw("same");
1210 TCanvas* cbaserms = 0;
1211 cbaserms = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("cbaserms");
1212 if(!cbaserms) cbaserms = CreateCanvas("cbaserms") ;
1215 // BASELINE RMS distribution
1216 fHistDistrBaseRmsIROC = fHistDistrBase2dIROC->ProjectionY("fHistDistrBaseRmsIROC");
1217 fHistDistrBaseRmsIROC->SetXTitle("base rms (ADC)");
1218 fHistDistrBaseRmsIROC->SetYTitle("counts");
1219 fHistDistrBaseRmsIROC->SetTitle(titleRMS.Data());
1220 fHistDistrBaseRmsIROC->Draw("");
1222 fHistDistrBaseRmsOROC = fHistDistrBase2dOROC->ProjectionY("fHistDistrBaseRmsOROC");
1223 fHistDistrBaseRmsOROC->SetLineColor(2);
1224 fHistDistrBaseRmsOROC->Draw("same");
1225 if(fHistDistrBaseRmsOROC->GetMaximum()>fHistDistrBaseRmsIROC->GetMaximum()) fHistDistrBaseRmsIROC->SetMaximum(fHistDistrBaseRmsOROC->GetMaximum()*1.1);
1226 legio->Draw("same");
1230 cbasemean->Update();
1235 // GLOBAL MAX ADC _________________________________
1236 if(GetProcNextEvent()==1)
1241 if(!(cglobC=(TCanvas*)gROOT->GetListOfCanvases()->FindObject("SIDE C all"))) cglobC = CreateCanvas("SIDE C all");
1242 if(!(cglobA=(TCanvas*)gROOT->GetListOfCanvases()->FindObject("SIDE A all"))) cglobA = CreateCanvas("SIDE A all");
1244 TString globtitle1=Form("SIDE A Run %05i (EventID %i)",fRunId,fEventNumber);
1245 TString globtitle2=Form("SIDE C Run %05i (EventID %i)",fRunId,fEventNumber);
1247 fHistGlobalMaxA->SetTitle(globtitle1.Data());
1248 fHistGlobalMaxC->SetTitle(globtitle2.Data());
1249 fHistGlobalMaxA->SetXTitle("x/mm");
1250 fHistGlobalMaxA->SetYTitle("y/mm");
1251 fHistGlobalMaxC->SetXTitle("x/mm");
1252 fHistGlobalMaxC->SetYTitle("y/mm");
1254 if(GetPedestals()==0) { fHistGlobalMaxA->SetZTitle("max adc (not baseline sub)"); fHistGlobalMaxC->SetZTitle("max adc (not baseline sub)"); }
1255 else { fHistGlobalMaxA->SetZTitle("max adc "); fHistGlobalMaxC->SetZTitle("max adc "); }
1257 fHistGlobalMaxA->SetMinimum(0.01);
1258 fHistGlobalMaxC->SetMinimum(0.01);
1260 cglobC->cd() ; fHistGlobalMaxC->Draw("COLZ");
1261 cglobA->cd() ; fHistGlobalMaxA->Draw("COLZ");
1263 TString nameom=Form(".x %s/TPC/AliTPCMonitorExec.C(3)",gSystem->Getenv("ALICE_ROOT"));
1267 if(fVerb)cout << " set exec " << nameom.Data() << endl;
1268 cglobC->AddExec("glob",nameom.Data());
1269 cglobA->AddExec("glob",nameom.Data());
1274 cglobC->DeleteExec("glob");
1275 cglobA->DeleteExec("glob");
1277 if(fVerb) cout << " set exec " << nameom.Data() << endl;
1278 cglobC->AddExec("glob",nameom.Data());
1279 cglobA->AddExec("glob",nameom.Data());
1291 //__________________________________________________________________
1292 void AliTPCMonitor::DrawRMSMap()
1294 // Draw 2Dim rms histos for IROC and OROC
1295 // and set executables for canvases
1297 TCanvas* crmsoroc =0;
1298 TCanvas* crmsiroc =0;
1299 if(!(crmsoroc = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("crmsoroc"))) crmsoroc = CreateCanvas("crmsoroc");
1300 if(!(crmsiroc = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("crmsiroc"))) crmsiroc = CreateCanvas("crmsiroc");
1302 crmsiroc->cd(); fHistIROCRMS->Draw("COLZ");
1303 crmsoroc->cd(); fHistOROCRMS->Draw("COLZ");
1305 TString carry1=Form(".x %s/TPC/AliTPCMonitorExec.C(1)",gSystem->Getenv("ALICE_ROOT"));
1306 TString carry2=Form(".x %s/TPC/AliTPCMonitorExec.C(2)",gSystem->Getenv("ALICE_ROOT"));
1308 if(fExecPadIrocRms==0)
1310 crmsiroc->AddExec("pad",carry1.Data());
1311 crmsiroc->AddExec("row",carry2.Data());
1315 if(fExecPadOrocRms==0)
1317 crmsoroc->AddExec("pad",carry1.Data());
1318 crmsoroc->AddExec("row",carry2.Data());
1329 //__________________________________________________________________
1330 void AliTPCMonitor::ExecPad()
1333 // Executable for Pad
1334 // Show time profile for channel the mouse is pointing at
1336 Int_t event = gPad->GetEvent();
1337 if (event != 51) return;
1339 TObject *select = gPad->GetSelected();
1341 if(!select->InheritsFrom("TH2")) { return; }
1342 gPad->GetCanvas()->FeedbackMode(kTRUE);
1345 Int_t px = gPad->GetEventX();
1346 Int_t py = gPad->GetEventY();
1347 Float_t upy = gPad->AbsPixeltoY(py);
1348 Float_t upx = gPad->AbsPixeltoX(px);
1349 Float_t y = gPad->PadtoY(upy);
1350 Float_t x = gPad->PadtoX(upx);
1355 // Char_t namehist[50];
1362 Float_t ybinmin = 0;
1363 Float_t ybinmax = 0;
1365 // Check wich Canvas executed the event
1367 namesel=select->GetName();
1368 if(namesel=="fHistOROC" || namesel=="fHistOROCRMS" || namesel=="fHistOROCTime" )
1372 projhist=Form("ProjectionOROC");
1373 namecanv=Form("coroc_ch");
1374 fHistIndex = fHistOROCIndex;
1376 if(namesel=="fHistIROC" || namesel=="fHistIROCRMS" || namesel=="fHistIROCTime" )
1380 projhist=Form("ProjectionIROC");
1381 namecanv=Form("ciroc_ch");
1382 fHistIndex = fHistIROCIndex;
1385 // Check if Canvas already existed and get Ranges from former Prjection histogram
1386 if((cpad=(TCanvas*)gROOT->GetListOfCanvases()->FindObject(namecanv)))
1389 if(gROOT->Get(projhist))
1392 xbinmin = ((TH1D*)gROOT->Get(projhist))->GetXaxis()->GetFirst();
1393 xbinmax = ((TH1D*)gROOT->Get(projhist))->GetXaxis()->GetLast();
1394 ybinmin = ((TH1D*)gROOT->Get(projhist))->GetMinimum();
1395 ybinmax = ((TH1D*)gROOT->Get(projhist))->GetMaximum();
1396 delete gROOT->Get("legfit");
1397 delete gROOT->Get("fg");
1402 cpad = CreateCanvas(namecanv); cpad->cd();
1406 if (!fHistIndex) return;
1407 Int_t testy = fHistIndex->GetYaxis()->FindBin(y);
1408 Int_t testx = fHistIndex->GetXaxis()->FindBin(x);
1409 Int_t binchannel = (Int_t)fHistIndex->GetCellContent(testx,testy);
1410 if(binchannel>30000 || binchannel<0) return;
1412 TH1D *hp=(TH1D*)gROOT->Get(projhist);
1413 if(!hp) hp=new TH1D(projhist,projhist,GetTimeBins(),0,GetTimeBins());//delete gROOT->Get(projhist);
1415 // TH1D *hp = (TH1D*)(((TH1D*)fHistChannelTime->ProjectionY("hp",binchannel,binchannel))->Clone(projhist));
1416 // TH1D *hp = fHistChannelTime->ProjectionY(projhist,binchannel,binchannel);
1418 Int_t nbinsx=fHistChannelTime->GetNbinsX();
1419 for (Int_t itb=0;itb<GetTimeBins();++itb){
1420 hp->GetArray()[itb]=fHistChannelTime->GetArray()[binchannel+itb*(nbinsx+2)];
1425 // Make title and Pave for channel Info
1426 Int_t npadRow , npad , nhw , nmax , hwadd;
1428 hwadd = (Int_t)fHistChannelTime->GetCellContent(binchannel,0);
1429 fPadUsedHwAddr = hwadd;
1431 if(rocid==0)npadRow = fMapHand->GetPadRow(hwadd);
1432 else npadRow = fMapHand->GetPadRow(hwadd)-63;
1433 npad = fMapHand->GetPad(hwadd);
1435 nmax = (Int_t)hp->GetMaximum();
1438 TPaveText* legstat = new TPaveText(0.18,0.65,0.3,0.8,"NDC");
1440 Int_t connector = fMapHand->GetFECconnector(hwadd);
1441 Int_t fecnr = fMapHand->GetFECfromHw(hwadd);
1442 Int_t fecch = fMapHand->GetFECchannel(hwadd);
1443 Int_t altrochip = fMapHand->GetAltro(hwadd);
1444 Int_t altrochannel= (fMapHand->GetAltroChannel(hwadd))%16;
1445 Int_t fecloc = fMapHand->U2fGetFECinRCU(fecnr) ;
1446 Int_t feclocbran = fMapHand->U2fGetFECinBranch(fecnr);
1447 Int_t branch = fMapHand->U2fGetBranch(fecnr);
1450 Short_t fecget = (hwadd & fgkHwMaskFEC) >> 7;
1451 Short_t branchget = (hwadd & fgkHwMaskBranch)>> 11;
1453 legstat->AddText(Form("Branch (map) \t %i (%i) \n",branchget,branch));
1454 legstat->AddText(Form("Fec in patch \t %i \n",fecloc));
1455 legstat->AddText(Form("Fec in branch (map)\t %i (%i)\n",fecget,feclocbran));
1456 legstat->AddText(Form("Connector \t %i \n",connector));
1457 legstat->AddText(Form("Fec No. \t %i \n",fecnr));
1458 legstat->AddText(Form("Fec chan \t %i \n",fecch));
1459 legstat->AddText(Form("Altro chip\t %i \n",altrochip));
1460 legstat->AddText(Form("Altro chan\t %i \n",altrochannel));
1462 TString title=Form("Row=%d Pad=%d Hw =%d maxADC =%d count =%d",npadRow,npad,nhw,nmax,binchannel);
1464 // hp->SetName(projhist);
1465 hp->SetTitleSize(0.04);
1466 hp->SetTitle(title.Data());
1467 hp->SetYTitle("ADC");
1468 hp->SetXTitle("Timebin");
1469 hp->GetXaxis()->SetTitleColor(1);
1473 hp->GetXaxis()->SetRange(xbinmin,xbinmax);
1474 hp->SetMinimum(ybinmin);
1475 hp->SetMaximum(ybinmax);
1479 hp->SetMinimum(0.0);
1480 hp->SetMaximum(1000.0);
1487 if(GetPedestals() && fDisableFit==0)
1489 Int_t maxx = (Int_t)fHistAddrMaxAdcX->GetBinContent(hwadd);
1490 Float_t max = (Float_t)fHistAddrMaxAdc->GetBinContent(hwadd);
1491 Float_t base = (Float_t)fHistAddrBaseMean->GetBinContent(hwadd);
1494 if( ((max+base)/base)>1.2)
1496 TF1* fg = new TF1("fg",AliTPCMonitor::Gamma4,maxx-5,maxx+5,4);
1497 fg->SetParName(0,"Normalisation");
1498 fg->SetParName(1,"Minimum");
1499 fg->SetParName(2,"Width");
1500 fg->SetParName(3,"Base");
1501 fg->SetParameter(0,max);
1502 fg->SetParameter(1,maxx-2);
1503 fg->SetParameter(2,1.5);
1504 fg->FixParameter(3,0);
1505 fg->SetLineColor(4);
1506 fg->SetLineWidth(1);
1509 TLegend* legfit = new TLegend(0.6,0.7,0.7,0.8);
1510 legfit->AddEntry("fg","#Gamma 4 fit","l");
1511 legfit->SetFillColor(0);
1512 legfit->SetName("legfit");
1513 legfit->Draw("same");
1517 legstat->SetFillColor(0);
1518 legstat->Draw("same");
1523 //__________________________________________________________________
1524 void AliTPCMonitor::ExecRow()
1527 // Executable for Pad
1528 // Show profile of max adc over given pad row
1529 // and 2dim histo adc(pad-in-row,time bin)
1531 Int_t event = gPad->GetEvent();
1532 if (event != 61) return;
1534 TObject *select = gPad->GetSelected();
1536 if(!select->InheritsFrom("TH2")) { return; }
1540 const Char_t *rowhist="hrowtime";
1541 const Char_t *rowhistxmax="hxmax";
1542 const Char_t *rowhistmax="hrowmax";
1545 Int_t px = gPad->GetEventX();
1546 Int_t py = gPad->GetEventY();
1547 Float_t upy = gPad->AbsPixeltoY(py);
1548 Float_t upx = gPad->AbsPixeltoX(px);
1549 Float_t y = gPad->PadtoY(upy);
1550 Float_t x = gPad->PadtoX(upx);
1552 TCanvas*crowtime = 0;
1553 TCanvas*crowmax = 0;
1556 TH2S* fHistIndex = 0;
1558 // ranges from already existing histos
1559 Int_t rowtimexmin = 0;
1560 Int_t rowtimexmax = 0;
1561 Int_t rowtimeymin = 0;
1562 Int_t rowtimeymax = 0;
1563 Float_t rowtimezmin = 0;
1564 Float_t rowtimezmax = 0;
1566 Int_t profrowxmin = 0;
1567 Int_t profrowxmax = 0;
1568 Double_t profrowymin = 0;
1569 Double_t profrowymax = 0;
1571 Int_t profxxmin = 0;
1572 Int_t profxxmax = 0;
1573 Double_t profxymin = 0;
1574 Double_t profxymax = 0;
1579 TString name=select->GetName();
1580 if( name=="fHistIROC" || name=="fHistIROCRMS" ) { fHistIndex = fHistIROCIndex; rocid =1; }
1581 else if(name=="fHistOROC" || name=="fHistOROCRMS" ) { fHistIndex = fHistOROCIndex; rocid =2; }
1582 else { cout << " not implemented for this histo " << endl; return; }
1584 gPad->GetCanvas()->FeedbackMode(kTRUE);
1588 // check if canvases exist //
1589 crowtime = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("crowtime");
1590 crowmax = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("crowmax");
1591 cxmax = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("cxmax");
1593 if(!crowtime) crowtime = CreateCanvas("crowtime") ;
1594 if(!crowmax) crowmax = CreateCanvas("crowmax") ;
1595 if(!cxmax ) cxmax = CreateCanvas("cxmax") ;
1597 // check ranges of already existing histos
1598 if(gROOT->Get(rowhist))
1600 rowtimexmin = ((TH2F*)gROOT->Get(rowhist))->GetXaxis()->GetFirst();
1601 rowtimexmax = ((TH2F*)gROOT->Get(rowhist))->GetXaxis()->GetLast();
1602 rowtimeymin = ((TH2F*)gROOT->Get(rowhist))->GetYaxis()->GetFirst();
1603 rowtimeymax = ((TH2F*)gROOT->Get(rowhist))->GetYaxis()->GetLast();
1604 rowtimezmin = ((TH2F*)gROOT->Get(rowhist))->GetMinimum();
1605 rowtimezmax = ((TH2F*)gROOT->Get(rowhist))->GetMaximum();
1607 profrowxmin = ((TH1F*)gROOT->Get(rowhistmax))->GetXaxis()->GetFirst();
1608 profrowxmax = ((TH1F*)gROOT->Get(rowhistmax))->GetXaxis()->GetLast();
1609 profrowymin = ((TH1F*)gROOT->Get(rowhistmax))->GetMinimum();
1610 profrowymax = ((TH1F*)gROOT->Get(rowhistmax))->GetMaximum();
1612 profxxmin = ((TH1F*)gROOT->Get(rowhistxmax))->GetXaxis()->GetFirst();
1613 profxxmax = ((TH1F*)gROOT->Get(rowhistxmax))->GetXaxis()->GetLast();
1614 profxymin = ((TH1F*)gROOT->Get(rowhistxmax))->GetMinimum();
1615 profxymax = ((TH1F*)gROOT->Get(rowhistxmax))->GetMaximum();
1619 delete gROOT->Get(rowhist);
1620 delete gROOT->Get(rowhistmax);
1621 delete gROOT->Get("hxmax");
1622 delete gROOT->Get("legrow");
1625 // get channel for xy bin -> getRow -> getNrows -> getHw for each Pad in Row -> get channel for each hw -> make proj
1626 Int_t testy = fHistIndex->GetYaxis()->FindBin(y);
1627 Int_t testx = fHistIndex->GetXaxis()->FindBin(x);
1628 Int_t binchannel = (Int_t)fHistIndex->GetCellContent(testx,testy);
1630 if(binchannel>30000) return;
1631 if(binchannel<=0 ) { crowtime->Update() ; crowmax->Update() ; return ; }
1634 Int_t hwadd = (Int_t)fHistChannelTime->GetCellContent(binchannel,0);
1635 Int_t row = fMapHand->GetPadRow(hwadd);
1636 Int_t pad = fMapHand->GetPad(hwadd) ;
1637 Int_t numofpads = fMapHand->GetNumofPads(row);
1640 TH2F *hrowtime = new TH2F(rowhist , "" ,numofpads,0,numofpads,GetTimeBins(),0.0,GetTimeBins());
1641 TH1F *hrowmax = new TH1F(rowhistmax , "" ,numofpads,0,numofpads);
1642 TH1F *hxmax = new TH1F(rowhistxmax, "" ,159,0,159 );
1644 // Row profile ///////////
1645 if(fVerb) cout << " Number of pads " << numofpads << endl;
1646 for(Int_t padnr = 0; padnr<numofpads;padnr++)
1648 Int_t addrinrow = fMapHand->GetPadAddInRow(row,padnr );
1649 Int_t channel = (Int_t)fHistAddrMapIndex->GetBinContent(addrinrow);
1650 if(channel==-1) continue;
1652 hrowmax->SetBinContent(padnr+1,fHistAddrMaxAdc->GetBinContent(addrinrow));
1653 TH1D *hp = fHistChannelTime->ProjectionY("hp",channel,channel);
1654 for(Int_t time = 0;time<GetTimeBins();time++) {
1656 Float_t val = hp->GetBinContent(time);
1657 hrowtime->SetCellContent(padnr+1,time+1,val);
1661 // X profile /////////////
1662 Double_t xval = 0.0;
1663 Double_t yval = 0.0;
1664 GetXY(xval,yval,numofpads,row,pad);
1668 for(Int_t nrow = 0; nrow<159; nrow++)
1670 padnr = GetPadAtX(xval,nrow);
1673 hw = fMapHand->GetPadAddInRow(nrow,padnr);
1674 if(fPadMapHw[hw]==-1){ continue ; }
1675 else { hxmax->SetBinContent(nrow+1,fHistAddrMaxAdc->GetBinContent(hw)) ; }
1680 hxmax->SetTitle(Form("max adc in pads at x=%5.1f mm",xval));
1681 hxmax->SetXTitle("row");
1682 if(!GetPedestals()) hxmax->SetYTitle("max adc (baseline sub.)");
1683 else hxmax->SetYTitle("max adc ");
1684 hxmax->SetMinimum(0.01);
1689 hxmax->GetXaxis()->SetRange(profxxmin,profxxmax);
1690 hxmax->SetMinimum(profxymin);
1691 hxmax->SetMaximum(profxymax);
1700 title.Form("%s Row=%d",((TH2*)select)->GetTitle(),row) ;
1701 titlemax.Form("IROC max/sum Row=%d",row );
1703 title.Form("%s Row=%d",((TH2*)select)->GetTitle(),row-63);
1704 titlemax.Form("OROC max/sum Row=%d",row-63);
1707 if(fVerb) cout << " set name " << endl;
1712 hrowtime->SetTitleSize(0.04);
1713 hrowtime->SetTitle(title.Data());
1714 hrowtime->SetYTitle("timbin");
1715 hrowtime->SetXTitle("pad in row");
1716 hrowtime->SetZTitle("signal (ADC)");
1718 hrowtime->GetXaxis()->SetTitleColor(1);
1719 hrowtime->SetMaximum(1000.0);
1720 hrowtime->SetMinimum(0.0);
1724 hrowtime->GetXaxis()->SetRange(rowtimexmin,rowtimexmax);
1725 hrowtime->GetYaxis()->SetRange(rowtimeymin,rowtimeymax);
1726 hrowtime->SetMinimum(rowtimezmin);
1727 hrowtime->SetMaximum(rowtimezmax);
1730 hrowtime->Draw("COLZ");
1731 crowtime->UseCurrentStyle();
1734 // max and sum /////////////////////////
1737 hrowmax->GetXaxis()->SetRange(profrowxmin,profrowxmax);
1738 hrowmax->SetMinimum(profrowymin);
1739 hrowmax->SetMaximum(profrowymax);
1741 hrowmax->SetTitleSize(0.04);
1742 hrowmax->SetTitle(title.Data());
1743 hrowmax->SetYTitle("max adc");
1744 hrowmax->SetXTitle("pad in row");
1745 hrowmax->GetXaxis()->SetTitleColor(1);
1747 hrowmax->SetLineColor(2);
1754 //__________________________________________________________________
1755 void AliTPCMonitor::Write10bitChannel()
1758 // Write 10 bit words form histogram for active(last pointed) channel
1760 if(fPadUsedHwAddr==-1){ AliWarning(" No active pad "); return ;}
1762 Int_t pad = (Int_t)fMapHand->GetPad( fPadUsedHwAddr);
1763 Int_t row = (Int_t)fMapHand->GetPadRow(fPadUsedHwAddr);
1764 Int_t channel = (Int_t)fPadMapHw[fPadUsedHwAddr];
1766 TString filenameroot;
1767 TString filenamedat;
1770 if(fPadUsedRoc==1) { projhist.Form("ProjectionOROC"); }
1771 if(fPadUsedRoc==0) { projhist.Form("ProjectionIROC"); }
1773 filenamedat.Form("Channel_Run%05i_EventID_%i_Pad_%i_Row_%i.dat" ,fRunId,fEventNumber,pad,row);
1774 filenameroot.Form("Channel_Run%05i_EventID_%i_Pad_%i_Row_%i.root" ,fRunId,fEventNumber,pad,row);
1777 if((hpr=(TH1D*)gROOT->Get(projhist)))
1780 TFile f(filenameroot.Data(),"recreate");
1785 ofstream datout(filenamedat.Data(),ios::out);
1786 datout <<"Timebin \t ADC value " << endl;
1787 for(Int_t i = 1; i <GetTimeBins(); i++)
1789 datout << i << " \t \t " << fPad[channel][i] << endl;
1795 AliWarning("No projection histo found ");
1799 //__________________________________________________________________
1800 void AliTPCMonitor::ExecTransform()
1803 // Make Fast Fourier Transformation for active pad
1804 // fft is only performed for a data sample of size 2^n
1805 // reduce window according to largest power of 2 which is smaller than the viewing range
1810 TString namehtrimag;
1811 TString namehtrreal;
1814 if(fPadUsedRoc==1) { namecanv="coroc_ch_trans"; namecanv2="coroc_ch_trans2"; projhist="ProjectionOROC"; }
1815 if(fPadUsedRoc==0) { namecanv="ciroc_ch_trans"; namecanv2="ciroc_ch_trans2"; projhist="ProjectionIROC"; }
1819 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 ;}
1820 else hproj = (TH1D*)gROOT->Get(projhist.Data()) ;
1823 if(fPadUsedRoc==1) { namehtrimag="htransimagfreq_oroc"; namehtrreal="htransrealfreq_oroc"; namehtrmag="htransmagfreq_oroc"; }
1824 else { namehtrimag="htransimagfreq_iroc"; namehtrreal="htransrealfreq_iroc"; namehtrmag="htransmagfreq_iroc"; }
1826 if( gROOT->Get(namehtrimag.Data())) delete gROOT->Get(namehtrimag.Data());
1827 if( gROOT->Get(namehtrreal.Data())) delete gROOT->Get(namehtrreal.Data());
1828 if( gROOT->Get(namehtrmag.Data())) delete gROOT->Get(namehtrmag.Data());
1830 TCanvas *ctrans = 0;
1831 if(!(ctrans = (TCanvas*)gROOT->GetListOfCanvases()->FindObject(namecanv.Data())))
1833 ctrans = CreateCanvas(namecanv.Data());
1834 ctrans->Divide(1,2);
1836 TCanvas *ctrans2 = 0;
1837 if(!(ctrans2 = (TCanvas*)gROOT->GetListOfCanvases()->FindObject(namecanv2.Data())))
1839 ctrans2 = CreateCanvas(namecanv2.Data());
1840 // ctrans2->Divide(1,2);
1843 Int_t binfirst = hproj->GetXaxis()->GetFirst();
1844 Int_t binlast = hproj->GetXaxis()->GetLast();
1845 Int_t bins = binlast -binfirst +1;
1848 for(Int_t pot = 0; pot<=10 ; pot++)
1850 Int_t comp = (Int_t)TMath::Power(2,pot);
1851 if(bins>=comp)power = pot;
1854 bins = (Int_t)TMath::Power(2,power);
1856 // sampling frequency ;
1857 Double_t deltat = 1.0/(Float_t)GetSamplingFrequency();
1860 TH1D* htransrealfreq = new TH1D(namehtrreal.Data(),namehtrreal.Data(),10000,-1/(2*deltat),1/(2*deltat));
1861 TH1D* htransimagfreq = new TH1D(namehtrimag.Data(),namehtrimag.Data(),10000,-1/(2*deltat),1/(2*deltat));
1862 TH1D* htransmag = new TH1D(namehtrmag.Data(),namehtrmag.Data(),10000,-1/(2*deltat),1/(2*deltat));
1867 if(fPadUsedRoc==1) { titlereal="OROC DFT real part"; titleimag="OROC DFT imag part"; titlemag="OROC DFT magnitude"; }
1868 else { titlereal="IROC DFT real part"; titleimag="IROC DFT imag part"; titlemag="IROC DFT magnitude"; }
1870 htransrealfreq->SetTitle(titlereal.Data()); htransrealfreq->SetXTitle("f/hz"); htransrealfreq->SetYTitle("z_{real}(f)");
1871 htransimagfreq->SetTitle(titleimag.Data()); htransimagfreq->SetXTitle("f/hz"); htransimagfreq->SetYTitle("z_{imag}(f)");
1872 htransmag->SetTitle(titlemag.Data()); htransmag->SetXTitle("f/hz"); htransmag->SetYTitle("mag(f)");
1874 // create complex packed data array
1875 const Int_t kdatasiz = 2*bins;
1876 Double_t* data = new Double_t[kdatasiz];
1877 for(Int_t i=0;i<2*bins;i++) { data[i] = 0.0;}
1878 for(Int_t i=0;i<bins;i++) { data[2*i] = (Double_t)hproj->GetBinContent(binfirst+i); }
1880 // make fourier transformation
1881 AliTPCMonitorFFT* four = new AliTPCMonitorFFT();
1882 four->ComplexRadix2ForwardWrap(data,1,bins);
1884 // write output and fill histos forward
1885 Double_t freq = 0.0;
1886 for(Int_t i=0;i<2*bins;i++)
1890 if(i<(bins/2)) { freq = i/(bins*deltat) ; }
1891 else { freq = -1*((bins-i)/(bins*deltat)); }
1892 htransrealfreq->Fill( freq,data[2*i] );
1893 htransimagfreq->Fill( freq,data[2*i+1]);
1894 htransmag->Fill( freq, TMath::Sqrt(data[2*i]*data[2*i]+data[2*i+1]*data[2*i+1]) );
1899 htransrealfreq->Draw();
1901 htransimagfreq->Draw();
1910 //__________________________________________________________________
1911 void AliTPCMonitor::ShowSel(const Int_t* compval)
1914 // Show only selected components
1915 // First restore original histogram from clone
1916 // Than remove all not matching pads form histos
1918 Int_t connector = 0;
1920 Int_t altrochip = 0;
1921 Int_t feclocbran = 0;
1928 Float_t maxiroc = fHistIROCClone->GetMaximum();
1929 Float_t maxoroc = fHistOROCClone->GetMaximum();
1932 // restore original histos
1933 for(Int_t row = 0; row<fkNRowsIroc; row++)
1935 for(Int_t pad = 0; pad<fkNPadsIroc; pad++)
1937 index = (Int_t)fHistIROCIndex->GetCellContent(row+1,pad+1);
1938 if(index==-1)continue;
1939 else fHistIROC->SetCellContent(row+1,pad+1,fHistIROCClone->GetCellContent(row+1,pad+1));
1942 for(Int_t row = 0; row<fkNRowsOroc; row++)
1944 for(Int_t pad = 0; pad<fkNPadsOroc; pad++)
1946 index = (Int_t)fHistOROCIndex->GetCellContent(row+1,pad+1);
1947 if(index==-1)continue;
1948 else fHistOROC->SetCellContent(row+1,pad+1,fHistOROCClone->GetCellContent(row+1,pad+1));
1953 // remove not matching entries from fHistIROC/fHistOROC
1956 TH2S* fHistIndex =0;
1960 for(Int_t row = 0; row< (fkNRowsIroc + fkNRowsOroc); row++)
1962 if(row<fkNRowsIroc) { fHist=fHistIROC ; fHistIndex = fHistIROCIndex; npads = fkNPadsIroc; subrows =0 ;}
1963 else { fHist=fHistOROC ; fHistIndex = fHistOROCIndex; npads = fkNPadsOroc; subrows =fkNRowsIroc;}
1965 for(Int_t pad = 0; pad<npads; pad++)
1967 index = (Int_t)fHistIndex->GetCellContent(row -subrows +1,pad+1);
1968 if(index==-1) continue ;
1969 hwadd = (Int_t)fHistChannelTime->GetCellContent(index,0);
1972 fecnr = fMapHand->GetFECfromHw(hwadd);
1973 if(compval[0]!=-1 && fecnr!=compval[0]) { fHist->SetCellContent(row-subrows+1,pad+1,0); continue; }
1976 rcuget = (hwadd & fgkHwMaskRCU)>> 12;
1977 if(compval[1]!=-1 && rcuget!=compval[1]) { fHist->SetCellContent(row-subrows+1,pad+1,0); continue; }
1980 branch = fMapHand->U2fGetBranch(fecnr) ;
1981 if(compval[2]!=-1 && branch!=compval[2]) { fHist->SetCellContent(row-subrows+1,pad+1,0); continue; }
1984 feclocbran= fMapHand->U2fGetFECinBranch(fecnr) ;
1985 if(compval[3]!=-1 && feclocbran!=compval[3]) { fHist->SetCellContent(row-subrows+1,pad+1,0); continue; }
1988 connector = fMapHand->GetFECconnector(hwadd);
1989 if(compval[4]!=-1 && connector!=compval[4]) { fHist->SetCellContent(row-subrows+1,pad+1,0); continue; }
1992 altrochip = fMapHand->GetAltro(hwadd);
1993 if(compval[5]!=-1 && altrochip!=compval[5]) { fHist->SetCellContent(row-subrows+1,pad+1,0); continue; }
2000 if(gROOT->GetListOfCanvases()->FindObject("ciroc"))
2002 c1 = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("ciroc");
2004 fHistIROC->Draw("COLZ");
2005 fHistIROC->SetMaximum(maxiroc);
2006 fHistIROC->SetMinimum(0.0);
2009 if(gROOT->GetListOfCanvases()->FindObject("coroc"))
2011 c2 = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("coroc");
2013 fHistOROC->Draw("COLZ");
2014 fHistOROC->SetMaximum(maxoroc);
2015 fHistOROC->SetMinimum(0.0);
2021 //__________________________________________________________________
2022 void AliTPCMonitor::ResizeCanv()
2024 // Resize canvases and delete some of them
2026 TString carry1=Form(".x %s/TPC/AliTPCMonitorExec.C(1)",gSystem->Getenv("ALICE_ROOT"));
2027 TString carry3=Form(".x %s/TPC/AliTPCMonitorExec.C(2)",gSystem->Getenv("ALICE_ROOT"));
2028 if(fVerb) cout << " canv 1 " << endl;
2030 if(gROOT->GetListOfCanvases()->FindObject( "coroc_ch")) { delete gROOT->GetListOfCanvases()->FindObject("coroc_ch") ; }
2031 if(gROOT->GetListOfCanvases()->FindObject( "ciroc_ch")) { delete gROOT->GetListOfCanvases()->FindObject("ciroc_ch") ; }
2033 // for 2dim plots delete create and draw again
2034 if(gROOT->GetListOfCanvases()->FindObject("ciroc"))
2036 delete gROOT->GetListOfCanvases()->FindObject("ciroc");
2037 TCanvas* ciroc = CreateCanvas("ciroc");
2039 fHistIROC->Draw("COLZ");
2040 ciroc->AddExec("pad",carry1.Data());
2041 ciroc->AddExec("row",carry3.Data());
2045 // for 2dim plots delete create and draw again
2046 if(gROOT->GetListOfCanvases()->FindObject("coroc"))
2048 delete gROOT->GetListOfCanvases()->FindObject("coroc");
2049 TCanvas* coroc = CreateCanvas("coroc");
2051 fHistOROC->Draw("COLZ");
2053 coroc->AddExec("pad",carry1.Data());
2054 coroc->AddExec("row",carry3.Data());
2059 if(gROOT->GetListOfCanvases()->FindObject( "cbasemean")) { delete gROOT->GetListOfCanvases()->FindObject("cbasemean"); }
2060 if(gROOT->GetListOfCanvases()->FindObject( "cbase")) { delete gROOT->GetListOfCanvases()->FindObject("cbase");}
2061 if(gROOT->GetListOfCanvases()->FindObject( "cbaserms")) { delete gROOT->GetListOfCanvases()->FindObject("cbaserms"); }
2062 if(gROOT->GetListOfCanvases()->FindObject( "cmax")) { delete gROOT->GetListOfCanvases()->FindObject("cmax"); }
2063 if(gROOT->GetListOfCanvases()->FindObject( "csum")) { delete gROOT->GetListOfCanvases()->FindObject("csum"); }
2064 if(gROOT->GetListOfCanvases()->FindObject( "ciroc_ch_trans")) { delete gROOT->GetListOfCanvases()->FindObject("ciroc_ch_trans");}
2065 if(gROOT->GetListOfCanvases()->FindObject( "coroc_ch_trans")) { delete gROOT->GetListOfCanvases()->FindObject("coroc_ch_trans");}
2066 if(gROOT->GetListOfCanvases()->FindObject( "crowtime")) { delete gROOT->GetListOfCanvases()->FindObject("crowtime"); }
2067 if(gROOT->GetListOfCanvases()->FindObject( "crowmax")) { delete gROOT->GetListOfCanvases()->FindObject("crowmax"); }
2068 if(gROOT->GetListOfCanvases()->FindObject( "cxmax")) { delete gROOT->GetListOfCanvases()->FindObject("cxmax"); }
2069 if(gROOT->GetListOfCanvases()->FindObject( "crmsoroc")) { delete gROOT->GetListOfCanvases()->FindObject("crmsoroc"); fExecPadOrocRms = 0; }
2070 if(gROOT->GetListOfCanvases()->FindObject( "crmsiroc")) { delete gROOT->GetListOfCanvases()->FindObject("crmsiroc"); fExecPadIrocRms = 0; }
2071 if(gROOT->GetListOfCanvases()->FindObject( "crowmax")) { delete gROOT->GetListOfCanvases()->FindObject("crowmax"); }
2072 if(gROOT->GetListOfCanvases()->FindObject( "crowmax")) { delete gROOT->GetListOfCanvases()->FindObject("crowmax"); }
2079 //__________________________________________________________________
2080 Int_t AliTPCMonitor::ExecProcess()
2082 // Executable for global Histogram
2083 // Will be called from /TPC/AliTPCMonitorExec.C(3)
2084 // Call ProcessEvent for same event and sector pointed at
2089 Int_t event = gPad->GetEvent();
2090 if(event != 61) return -1;
2092 TObject *select = gPad->GetSelected();
2093 if(!select) return -1;
2094 TString name=select->GetName();
2095 if(!select->InheritsFrom("TH2")) {gPad->SetUniqueID(0); return -1; }
2096 if( name=="hglobal" || name=="SIDE A" ) side = 0;
2097 else if( name=="hglobal2" || name=="SIDE C" ) side = 1;
2100 Int_t px = gPad->GetEventX();
2101 Int_t py = gPad->GetEventY();
2102 Float_t upy = gPad->AbsPixeltoY(py);
2103 Float_t upx = gPad->AbsPixeltoX(px);
2104 Float_t y = gPad->PadtoY(upy);
2105 Float_t x = gPad->PadtoX(upx);
2107 Int_t testy = ((TH2*)select)->GetYaxis()->FindBin(y);
2108 Int_t testx = ((TH2*)select)->GetXaxis()->FindBin(x);
2109 if(((TH2*)select)->GetCellContent(testx,testy)==0) return -1 ;
2111 Float_t alpha = 0.0;
2112 if(x>0.0 && y > 0.0) alpha = TMath::Abs(TMath::ATan(TMath::Abs(x/y)));
2113 if(x>0.0 && y < 0.0) alpha = TMath::Abs(TMath::ATan(TMath::Abs(y/x)));
2114 if(x<0.0 && y < 0.0) alpha = TMath::Abs(TMath::ATan(TMath::Abs(x/y)));
2115 if(x<0.0 && y > 0.0) alpha = TMath::Abs(TMath::ATan(TMath::Abs(y/x)));
2117 if(x>0.0 && y < 0.0) alpha += ( TMath::Pi()/2);
2118 if(x<0.0 && y < 0.0) alpha += ( TMath::Pi());
2119 if(x<0.0 && y > 0.0) alpha += (1.5*TMath::Pi());
2121 sector = (Int_t)(alpha/(2*TMath::Pi()/18.0));
2122 if(alpha> (sector+0.5)*(2*TMath::Pi()/18.0)) sector+=1;
2124 if(sector==18 && side ==0 ) {
2125 AliWarning("There was a wromg assignment of sector 0 with sector 18. Check sectors");
2129 sector = (18-sector +4)%18;
2130 SetLastSector(sector+ side*18);
2131 SetProcNextEvent(0);
2133 if(fVerb) cout << "AliTPCMonitor::ExecProcess() next side " << side << " next sector " << sector << endl;
2135 return (Int_t)ProcessEvent();
2139 //__________________________________________________________________
2140 Int_t AliTPCMonitor::GetRCUPatch(Int_t runid, Int_t eqid) const
2143 // Return RCU patch index for given equipment id eqid
2148 if ( eqid<768 || eqid>983 ) return 0; //no TPC eqid
2149 // if(eqid>=1000) return 0;
2150 patch = fMapEqidsRcu[eqid] ;
2154 if(eqid==408) {patch = 13*6+4 +0; }
2155 if(eqid==409) {patch = 13*6+5 +0; }
2156 if(eqid==509) {patch = 13*6+0 +0; }
2157 if(eqid==512) {patch = 13*6+3 +0; }
2158 if(eqid==513) {patch = 13*6+1 +0; }
2159 if(eqid==517) {patch = 13*6+2 +0; }
2161 if(eqid==404) {patch = 4*6+5 +0; }
2162 if(eqid==504) {patch = 4*6+4 +0; }
2163 if(eqid==407) {patch = 4*6+3 +0; }
2164 if(eqid==503) {patch = 4*6+2 +0; }
2165 if(eqid==508) {patch = 4*6+1 +0; }
2166 if(eqid==506) {patch = 4*6+0 +0; }
2171 //__________________________________________________________________
2172 void AliTPCMonitor::DumpHeader(AliRawReader * reader) const
2174 // Dump Event header for format
2176 cout << "EventHeader : fReader->GetEquipmentSize() :" << reader->GetEquipmentSize() << endl;
2177 cout << "EventHeader : fReader->GetType() :" << reader->GetType() << endl;
2178 cout << "EventHeader : fReader->GetRunNumber() :" << reader->GetRunNumber() << endl;
2179 cout << "EventHeader : fReader->GetEventId() :" << *(reader->GetEventId()) << endl;
2180 cout << "EventHeader : fReader->GetLDCId() :" << reader->GetLDCId() << endl;
2181 cout << "EventHeader : fReader->GetGDCId() :" << reader->GetGDCId() << endl;
2185 //__________________________________________________________________
2186 Double_t AliTPCMonitor::Gamma4(const Double_t* x, const Double_t* par) {
2188 // Gamma4 function used to fit signals
2189 // Defined in sections: diverging branch set to 0
2193 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];
2199 //__________________________________________________________________
2200 TCanvas* AliTPCMonitor::CreateCanvas(const Char_t* name)
2206 Int_t xoffset = GetCanvasXOffset();
2207 Int_t xsize = GetCanvasXSize();
2208 Int_t ysize = GetCanvasYSize();
2209 Int_t xspace = GetCanvasXSpace();
2210 Int_t yspace = GetCanvasYSpace();
2213 // ROC 2dim max distribution
2214 if( sname=="coroc") { 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; }
2215 else if(sname=="ciroc") { canv = new TCanvas("ciroc" ,"ciroc" , -1+xoffset, 0 ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2216 // ROC 2dim rms distribution
2217 else if(sname=="crmsoroc") { 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; }
2218 else if(sname=="crmsiroc") { canv = new TCanvas("crmsiroc" ,"crmsiroc" , -1+xoffset, 0 ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2219 // Global ADC max Histos
2220 else if(sname=="SIDE C all") { 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; }
2221 else if(sname=="SIDE A all") { 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; }
2222 // 1 dim max sum basekine distribution
2223 else if(sname=="cmax") { canv = new TCanvas("cmax" ,"cmax" , -1+xoffset, 3*yspace ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv; }
2224 else if(sname=="csum") { canv = new TCanvas("csum" ,"csum" , xspace+xoffset, 3*yspace ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv; }
2225 else if(sname=="cbasemean") { canv = new TCanvas("cbasemean" ,"cbasemean" , 2*xspace+xoffset, 3*yspace ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv; }
2226 else if(sname=="cbaserms") { canv = new TCanvas("cbaserms" ,"cbaserms" , 3*xspace+xoffset, 3*yspace ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv; }
2227 // Projections of single channel
2228 else if(sname=="coroc_ch") { 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; }
2229 else if(sname=="ciroc_ch") { 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; }
2230 // FFT for single channel
2231 else if(sname=="coroc_ch_trans") { 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; }
2232 else if(sname=="ciroc_ch_trans") { 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; }
2233 else if(sname=="coroc_ch_trans2") { 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; }
2234 else if(sname=="ciroc_ch_trans2") { 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; }
2235 // row profile histograms
2236 else if(sname=="crowtime") { canv = new TCanvas("crowtime" ,"crowtime" , 1*xspace+xoffset, 2*yspace +ysize ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv; }
2237 else if(sname=="crowmax") { canv = new TCanvas("crowmax" ,"crowmax" , 2*xspace+xoffset, 2*yspace +ysize ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv; }
2238 else if(sname=="cxmax") { canv = new TCanvas("cxmax" ,"cxmax" , 3*xspace+xoffset, 2*yspace +ysize ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv; }
2239 else { cout << " Warning Canvas name unknown " << endl; return 0 ; }
2242 //__________________________________________________________________
2243 void AliTPCMonitor::WriteHistos()
2245 // Writes all available histograms to a file in current directory
2246 // File name will be specified by : sector, side, runid and eventnumber
2248 if(GetEventProcessed())
2250 AliInfo("Write histos to file");
2251 TString name=Form("SIDE_%i_SECTOR_%02i_RUN_%05i_EventID_%06i.root",(GetLastSector()/18),(GetLastSector()%18),fRunId,fEventNumber);
2252 TFile* f = new TFile(name.Data(),"recreate");
2253 for(Int_t i =0; i<fHistList->GetEntries(); i++)
2255 if(((TH1*)fHistList->At(i))!=0)
2257 ((TH1*)fHistList->At(i))->Write();
2265 AliError("No Event Processed : Chose Format , File and push 'Next Event' ");
2270 //__________________________________________________________________
2271 TH1* AliTPCMonitor::GetHisto(char* histname)
2274 // Returns histogram specified by histname
2275 // check available names for histos in CreateHistos()
2278 if((TH1*)fHistList->FindObject(histname))
2280 hist = (TH1*)fHistList->FindObject(histname);
2284 cout << " AliTPCMonitor::GetHisto :: Can not find histo with name " << histname << endl;
2289 //_________________________________
2290 void AliTPCMonitor::SetupMonitoringTable(const char* table)
2293 // Setup the monitoring table
2295 fMonTableChanged=kFALSE;
2296 TString newTable(table);
2298 //check if we have a new table
2299 if (newTable==fMonTableString) return;
2300 fMonTableString=newTable;
2304 delete fMonTableArray;
2307 //parse table request
2308 fMonTableArray=fMonTableString.Tokenize(",;");
2309 fMonTableArray->SetOwner();
2312 Int_t entries=fMonTableArray->GetEntries();
2314 AliError(Form("Monitoring table has to be given in muliples of 4\nEntries need to be sparated by ',' or ';'\nCannot parse the current table request: %s",fMonTableString.Data()));
2315 delete fMonTableArray;
2320 fkMonTable=new const Char_t*[entries+1];
2321 for (Int_t i=0;i<entries;++i) fkMonTable[i]=fMonTableArray->At(i)->GetName();
2322 fkMonTable[entries]=0x0;
2324 fMonTableChanged=kTRUE;