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
48 /////////////////////////////////////////////////////////////////////////
53 #include "AliTPCMonitor.h"
54 #include "AliTPCMonitorMappingHandler.h"
55 #include "AliTPCMonitorDateFile.h"
56 #include "AliTPCMonitorDateFormat.h"
57 #include "AliTPCMonitorAltro.h"
58 #include "AliTPCMonitorFFT.h"
59 #include "AliRawReaderRoot.h"
60 #include "AliRawReader.h"
61 #include "AliRawEventHeaderBase.h"
69 #include "TDirectory.h"
71 #include "TPaveText.h"
73 #include <Riostream.h>
74 #include "AliTPCMonitorDateMonitor.h"
76 ClassImp(AliTPCMonitor)
78 //____________________________________________________________________________
79 AliTPCMonitor::AliTPCMonitor(char* name, char* title) :
80 AliTPCMonitorConfig(name,title),
81 fPad(new Int_t*[GetMaxHwAddr()]),
82 fPadMapHw(new Float_t[GetMaxHwAddr()]),
83 fPadMapRCU(new Int_t*[GetMaxHwAddr()]),
101 fHistAddrBaseMean(0),
105 fHistDistrSumIROC(0),
106 fHistDistrMaxIROC(0),
107 fHistDistrSumOROC(0),
108 fHistDistrMaxOROC(0),
109 fHistDistrBase2dIROC(0),
110 fHistDistrBase2dOROC(0),
111 fHistDistrBaseRmsIROC(0),
112 fHistDistrBaseMeanIROC(0),
113 fHistDistrBaseRmsOROC(0),
114 fHistDistrBaseMeanOROC(0),
117 fHistList(new TObjArray()),
144 fMapEqidsSec(new Int_t*[36]),
145 fMapEqidsRcu(new Int_t[1000]),
155 for(Int_t i = 0; i<GetMaxHwAddr(); i++) { fPad[i] = new Int_t[GetTimeBins()];}
156 for(Int_t i = 0; i<GetMaxHwAddr(); i++) { fPadMapRCU[i] = new Int_t[6];}
157 for(Int_t i = 0; i<36; i++) { fMapEqidsSec[i] = new Int_t[6];}
161 if (!gDirectory->GetList())
163 Warning("Build","Current directory is not a valid directory");
166 AliTPCMonitor *hold = (AliTPCMonitor*)gDirectory->GetList()->FindObject(GetName());
169 Warning("Build","Replacing existing histogram: %s (Potential memory leak).",GetName());
170 gDirectory->GetList()->Remove(hold);
172 gDirectory->Append(this);
179 //____________________________________________________________________________
180 AliTPCMonitor::AliTPCMonitor(const AliTPCMonitor &monitor):
181 AliTPCMonitorConfig(monitor.GetName(),monitor.GetTitle()),
182 fPad(new Int_t*[GetMaxHwAddr()]),
183 fPadMapHw(new Float_t[GetMaxHwAddr()]),
184 fPadMapRCU(new Int_t*[GetMaxHwAddr()]),
200 fHistAddrMapIndex(0),
202 fHistAddrBaseMean(0),
206 fHistDistrSumIROC(0),
207 fHistDistrMaxIROC(0),
208 fHistDistrSumOROC(0),
209 fHistDistrMaxOROC(0),
210 fHistDistrBase2dIROC(0),
211 fHistDistrBase2dOROC(0),
212 fHistDistrBaseRmsIROC(0),
213 fHistDistrBaseMeanIROC(0),
214 fHistDistrBaseRmsOROC(0),
215 fHistDistrBaseMeanOROC(0),
218 fHistList(new TObjArray()),
219 fkNRowsIroc(monitor.fkNRowsIroc),
220 fkNRowsOroc(monitor.fkNRowsOroc),
221 fkNPadsIroc(monitor.fkNPadsIroc),
222 fkNPadsOroc(monitor.fkNPadsOroc),
223 fkNPadMinIroc(monitor.fkNPadMinIroc),
224 fkNPadMinOroc(monitor.fkNPadMinOroc),
225 fkNPadMaxIroc(monitor.fkNPadMaxIroc),
226 fkNPadMaxOroc(monitor.fkNPadMaxOroc),
227 fVerb(monitor.fVerb),
228 fLastEv(monitor.fLastEv),
229 fEventNumber(monitor.fEventNumber),
230 fEventNumberOld(monitor.fEventNumberOld),
231 fDisableFit(monitor.fDisableFit),
232 fExecGlob(monitor.fExecGlob),
233 fExecPlaneMax(monitor.fExecPlaneMax),
234 fExecPadIrocRms(monitor.fExecPadIrocRms),
235 fExecPadOrocRms(monitor.fExecPadOrocRms),
236 fRunId(monitor.fRunId),
237 fEqId(monitor.fEqId),
238 fPadUsedRoc(monitor.fPadUsedRoc),
239 fPadUsedHwAddr(monitor.fPadUsedHwAddr),
240 fGdcId(monitor.fGdcId),
241 fLdcId(monitor.fLdcId),
242 fLdcIdOld(monitor.fLdcIdOld),
243 fMapEqidsSec(new Int_t*[36]),
244 fMapEqidsRcu(new Int_t[1000]),
245 fMirror(monitor.fMirror),
246 fChannelIter(monitor.fChannelIter),
247 fMapHand(monitor.fMapHand),
248 fReaderROOT(monitor.fReaderROOT),
249 fReaderDATE(monitor.fReaderDATE),
250 fReaderDATEMon(monitor.fReaderDATEMon)
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);
269 fHistChannelTime=(TH2F*)monitor.fHistChannelTime->Clone(); fHistList->Add(fHistChannelTime);
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);
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);
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);
291 fHistGlobalMaxA=(TH2S*)monitor.fHistGlobalMaxA->Clone(); fHistList->Add(fHistGlobalMaxA);
292 fHistGlobalMaxC=(TH2S*)monitor.fHistGlobalMaxC->Clone(); fHistList->Add(fHistGlobalMaxC);
294 // fPad = new Int_t*[monitor.GetMaxHwAddr()];
295 for(Int_t i = 0; i<GetMaxHwAddr(); i++) { fPad[i] = new Int_t[monitor.GetTimeBins()];}
297 //fPadMapRCU = new Int_t*[monitor.GetMaxHwAddr()];
298 for(Int_t i = 0; i<monitor.GetMaxHwAddr(); i++) { fPadMapRCU[i] = new Int_t[6];}
300 //fPadMapHw = new Float_t[monitor.GetMaxHwAddr()];
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];}
309 if (!gDirectory->GetList())
311 Warning("Build","Current directory is not a valid directory");
316 AliTPCMonitor *hold = (AliTPCMonitor*)gDirectory->GetList()->FindObject(monitor.GetName());
319 Warning("Build","Replacing existing histogram: %s (Potential memory leak).",monitor.GetName());
320 gDirectory->GetList()->Remove(hold);
322 gDirectory->Append(this);
328 //____________________________________________________________________________
330 AliTPCMonitor &AliTPCMonitor:: operator= (const AliTPCMonitor& monitor)
332 // assigment operator
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;
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;
355 fPadUsedRoc=monitor.fPadUsedRoc;
356 fPadUsedHwAddr=monitor.fPadUsedHwAddr;
357 fGdcId=monitor.fGdcId;
358 fLdcId=monitor.fLdcId;
359 fLdcIdOld=monitor.fLdcIdOld;
360 fMapHand=monitor.fMapHand;
361 fReaderROOT=monitor.fReaderROOT;
362 fReaderDATE=monitor.fReaderDATE;
365 fHistList = new TObjArray();
366 fHistIROC=(TH2F*)monitor.fHistIROC->Clone(); fHistList->Add(fHistIROC);
367 fHistOROC=(TH2F*)monitor.fHistOROC->Clone(); fHistList->Add(fHistOROC);
368 fHistIROCIndex=(TH2S*)monitor.fHistIROCIndex->Clone(); fHistList->Add(fHistIROCIndex);
369 fHistOROCIndex=(TH2S*)monitor.fHistOROCIndex->Clone(); fHistList->Add(fHistOROCIndex);
370 fHistIROCTime=(TH2F*)monitor.fHistIROCTime->Clone(); fHistList->Add(fHistIROCTime);
371 fHistOROCTime=(TH2F*)monitor.fHistOROCTime->Clone(); fHistList->Add(fHistOROCTime);
372 fHistIROCClone=(TH2F*)monitor.fHistIROCClone->Clone(); fHistList->Add(fHistIROCClone);
373 fHistOROCClone=(TH2F*)monitor.fHistOROCClone->Clone(); fHistList->Add(fHistOROCClone);
374 fHistIROCRMS=(TH2F*)monitor.fHistIROCRMS->Clone(); fHistList->Add(fHistIROCRMS);
375 fHistOROCRMS=(TH2F*)monitor.fHistOROCRMS->Clone(); fHistList->Add(fHistOROCRMS);
376 fHistIROCBASE=(TH2F*)monitor.fHistIROCBASE->Clone(); fHistList->Add(fHistIROCBASE);
377 fHistOROCBASE=(TH2F*)monitor.fHistOROCBASE->Clone(); fHistList->Add(fHistOROCBASE);
378 fHistIROCSUM=(TH2F*)monitor.fHistIROCSUM->Clone(); fHistList->Add(fHistIROCSUM);
379 fHistOROCSUM=(TH2F*)monitor.fHistOROCSUM->Clone(); fHistList->Add(fHistOROCSUM);
381 fHistChannelTime=(TH2F*)monitor.fHistChannelTime->Clone(); fHistList->Add(fHistChannelTime);
383 fHistAddrMapIndex=(TH1F*)monitor.fHistAddrMapIndex->Clone(); fHistList->Add(fHistAddrMapIndex);
384 fHistAddrMaxAdc=(TH1F*)monitor.fHistAddrMaxAdc->Clone(); fHistList->Add(fHistAddrMaxAdc);
385 fHistAddrBaseMean=(TH1F*)monitor.fHistAddrBaseMean->Clone(); fHistList->Add(fHistAddrBaseMean);
386 fHistAddrMaxAdcX=(TH1F*)monitor.fHistAddrMaxAdcX->Clone(); fHistList->Add(fHistAddrMaxAdcX);
387 fHistAddrAdcSum=(TH1F*)monitor.fHistAddrAdcSum->Clone(); fHistList->Add(fHistAddrAdcSum);
388 fHistAddrBaseRms=(TH1F*)monitor.fHistAddrBaseRms->Clone(); fHistList->Add(fHistAddrBaseRms);
391 fHistDistrSumIROC=(TH1F*)monitor.fHistDistrSumIROC->Clone(); fHistList->Add(fHistDistrSumIROC);
392 fHistDistrMaxIROC=(TH1F*)monitor.fHistDistrMaxIROC->Clone(); fHistList->Add(fHistDistrMaxIROC);
393 fHistDistrSumOROC=(TH1F*)monitor.fHistDistrSumOROC->Clone(); fHistList->Add(fHistDistrSumOROC);
394 fHistDistrMaxOROC=(TH1F*)monitor.fHistDistrMaxOROC->Clone(); fHistList->Add(fHistDistrMaxOROC);
396 fHistDistrBase2dIROC=(TH2F*)monitor.fHistDistrBase2dIROC->Clone(); fHistList->Add(fHistDistrBase2dIROC);
397 fHistDistrBase2dOROC=(TH2F*)monitor.fHistDistrBase2dOROC->Clone(); fHistList->Add(fHistDistrBase2dOROC);
398 fHistDistrBaseRmsIROC=(TH1D*)monitor.fHistDistrBaseRmsIROC->Clone(); fHistList->Add(fHistDistrBaseRmsIROC);
399 fHistDistrBaseMeanIROC=(TH1D*)monitor.fHistDistrBaseMeanIROC->Clone(); fHistList->Add(fHistDistrBaseMeanIROC);
400 fHistDistrBaseRmsOROC=(TH1D*)monitor.fHistDistrBaseRmsOROC->Clone(); fHistList->Add(fHistDistrBaseRmsOROC);
401 fHistDistrBaseMeanOROC=(TH1D*)monitor.fHistDistrBaseMeanOROC->Clone(); fHistList->Add(fHistDistrBaseMeanOROC);
403 fHistGlobalMaxA=(TH2S*)monitor.fHistGlobalMaxA->Clone(); fHistList->Add(fHistGlobalMaxA);
404 fHistGlobalMaxC=(TH2S*)monitor.fHistGlobalMaxC->Clone(); fHistList->Add(fHistGlobalMaxC);
406 fPad = new Int_t*[monitor.GetMaxHwAddr()];
407 for(Int_t i = 0; i<GetMaxHwAddr(); i++) { fPad[i] = new Int_t[monitor.GetTimeBins()];}
409 fPadMapRCU = new Int_t*[monitor.GetMaxHwAddr()];
410 for(Int_t i = 0; i<monitor.GetMaxHwAddr(); i++) { fPadMapRCU[i] = new Int_t[6];}
412 fPadMapHw = new Float_t[monitor.GetMaxHwAddr()];
414 fMapEqidsRcu = new Int_t[1000];
415 fMapEqidsSec = new Int_t*[36];
416 for(Int_t i = 0; i<36; i++) { fMapEqidsSec[i] = new Int_t[6];}
421 if (!gDirectory->GetList())
423 Warning("Build","Current directory is not a valid directory");
426 AliTPCMonitor *hold = (AliTPCMonitor*)gDirectory->GetList()->FindObject(monitor.GetName());
429 Warning("Build","Replacing existing histogram: %s (Potential memory leak).",monitor.GetName());
430 gDirectory->GetList()->Remove(hold);
432 gDirectory->Append(this);
434 fReaderDATEMon=monitor.fReaderDATEMon;
440 //____________________________________________________________________________
441 AliTPCMonitor::~AliTPCMonitor()
445 for(Int_t i = 0; i<GetMaxHwAddr(); i++) { delete[] fPad[i] ;}
446 for(Int_t i = 0; i<GetMaxHwAddr(); i++) { delete[] fPadMapRCU[i];}
451 //____________________________________________________________________________
452 void AliTPCMonitor::CreateHistos()
454 // Create histograms to be displayed
456 if(fVerb) cout << " create new ones " << endl;
457 fHistIROC = new TH2F("fHistIROC" ,"fHistIROC" ,fkNRowsIroc,0,fkNRowsIroc,fkNPadsIroc, fkNPadMinIroc, fkNPadMaxIroc); fHistList->Add(fHistIROC);
458 fHistOROC = new TH2F("fHistOROC" ,"fHistOROC" ,fkNRowsOroc,0,fkNRowsOroc,fkNPadsOroc, fkNPadMinOroc, fkNPadMaxOroc); fHistList->Add(fHistOROC);
460 fHistIROCIndex = new TH2S("fHistIROCIndex" ,"fHistIROCIndex" ,fkNRowsIroc,0,fkNRowsIroc,fkNPadsIroc, fkNPadMinIroc, fkNPadMaxIroc); fHistList->Add(fHistIROCIndex);
461 fHistOROCIndex = new TH2S("fHistOROCIndex" ,"fHistOROCIndex" ,fkNRowsOroc,0,fkNRowsOroc,fkNPadsOroc, fkNPadMinOroc, fkNPadMaxOroc); fHistList->Add(fHistOROCIndex);
463 fHistIROCTime = new TH2F("fHistIROCTime" ,"fHistIROCTime" ,fkNRowsIroc,0,fkNRowsIroc,fkNPadsIroc, fkNPadMinIroc, fkNPadMaxIroc); fHistList->Add(fHistIROCTime);
464 fHistOROCTime = new TH2F("fHistOROCTime" ,"fHistOROCTime" ,fkNRowsOroc,0,fkNRowsOroc,fkNPadsOroc, fkNPadMinOroc, fkNPadMaxOroc); fHistList->Add(fHistOROCTime);
466 fHistIROCRMS = new TH2F("fHistIROCRMS" ,"fHistIROCRMS" ,fkNRowsIroc,0,fkNRowsIroc,fkNPadsIroc, fkNPadMinIroc, fkNPadMaxIroc); fHistList->Add(fHistIROCRMS);
467 fHistOROCRMS = new TH2F("fHistOROCRMS" ,"fHistOROCRMS" ,fkNRowsOroc,0,fkNRowsOroc,fkNPadsOroc, fkNPadMinOroc, fkNPadMaxOroc); fHistList->Add(fHistOROCRMS);
469 fHistIROCSUM = new TH2F("fHistIROCSUM" ,"fHistIROCSUM" ,fkNRowsIroc,0,fkNRowsIroc,fkNPadsIroc, fkNPadMinIroc, fkNPadMaxIroc); fHistList->Add(fHistIROCSUM);
470 fHistOROCSUM = new TH2F("fHistOROCSUM" ,"fHistOROCSUM" ,fkNRowsOroc,0,fkNRowsOroc,fkNPadsOroc, fkNPadMinOroc, fkNPadMaxOroc); fHistList->Add(fHistOROCSUM);
472 fHistIROCBASE = new TH2F("fHistIROCBASE" ,"fHistIROCBASE" ,fkNRowsIroc,0,fkNRowsIroc,fkNPadsIroc, fkNPadMinIroc, fkNPadMaxIroc); fHistList->Add(fHistIROCBASE);
473 fHistOROCBASE = new TH2F("fHistOROCBASE" ,"fHistOROCBASE" ,fkNRowsOroc,0,fkNRowsOroc,fkNPadsOroc, fkNPadMinOroc, fkNPadMaxOroc); fHistList->Add(fHistOROCBASE);
476 fHistChannelTime = new TH2F("fHistChannelTime" ,"fHistChannelTime" ,GetNumOfChannels(),0,GetNumOfChannels(),GetTimeBins(),0,GetTimeBins());fHistList->Add(fHistChannelTime);
477 fHistAddrMapIndex = new TH1F("fHistAddrMapIndex" ,"fHistAddrMapIndex" ,GetMaxHwAddr() ,0,GetMaxHwAddr()); fHistList->Add(fHistAddrMapIndex);
478 fHistAddrMaxAdc = new TH1F("fHistAddrMaxAdc" ,"fHistAddrMaxAdc" ,GetMaxHwAddr(),0,GetMaxHwAddr()); fHistList->Add(fHistAddrMaxAdc);
479 fHistAddrMaxAdcX = new TH1F("fHistAddrMaxAdcX" ,"fHistAddrMaxAdcX" ,GetMaxHwAddr(),0,GetMaxHwAddr()); fHistList->Add(fHistAddrMaxAdcX);
480 fHistAddrBaseMean = new TH1F("fHistAddrBaseMean" ,"fHistAddrBaseMean" ,GetMaxHwAddr(),0,GetMaxHwAddr()); fHistList->Add(fHistAddrBaseMean);
481 fHistAddrAdcSum = new TH1F("fHistAddrAdcSum" ,"fHistAddrAdcSum" ,GetMaxHwAddr(),0,GetMaxHwAddr()); fHistList->Add(fHistAddrAdcSum);
482 fHistAddrBaseRms = new TH1F("fHistAddrBaseRms" ,"fHistAddrBaseRms" ,GetMaxHwAddr(),0,GetMaxHwAddr()); fHistList->Add(fHistAddrBaseRms);
483 fHistDistrSumIROC = new TH1F("fHistDistrSumIROC" ,"fHistDistrSumIROC" ,400,0.0,4000.0); fHistList->Add(fHistDistrSumIROC);
484 fHistDistrMaxIROC = new TH1F("fHistDistrMaxIROC" ,"fHistDistrMaxIROC" ,500,0.0,1000.0); fHistList->Add(fHistDistrMaxIROC);
485 fHistDistrSumOROC = new TH1F("fHistDistrSumOROC" ,"fHistDistrSumOROC" ,400,0.0,4000.0); fHistList->Add(fHistDistrSumOROC);
486 fHistDistrMaxOROC = new TH1F("fHistDistrMaxOROC" ,"fHistDistrMaxOROC" ,500,0.0,1000.0); fHistList->Add(fHistDistrMaxOROC);
488 fHistDistrBase2dIROC = new TH2F("fHistDistrBase2dIROC" ,"fHistDistrBase2dIROC",100,0.0,100.0,100,0.0,10.0); fHistList->Add(fHistDistrBase2dIROC);
489 fHistDistrBase2dOROC = new TH2F("fHistDistrBase2dOROC" ,"fHistDistrBase2dOROC",100,0.0,100.0,100,0.0,10.0); fHistList->Add(fHistDistrBase2dOROC);
491 fHistGlobalMaxA = new TH2S("SIDE A" ,"SIDE A" ,500,-3000,3000,500,-3000,3000); fHistList->Add(fHistGlobalMaxA);
492 fHistGlobalMaxC = new TH2S("SIDE C" ,"SIDE C" ,500,-3000,3000,500,-3000,3000); fHistList->Add(fHistGlobalMaxC);
496 //____________________________________________________________________________
497 Int_t AliTPCMonitor::ProcessEvent()
500 // Depending on the value of the sector id all sectors (sectorid == -1) are processed.
502 // In this case only the maximum values are calculated per pad and filled to the global histograms
503 // In a second loop the last processed(displayed) sector will be processed (sectorid!=-1)
504 // again and the baseline rms and further quantities are calculated
506 // If only one sector should be processed SetProcOneSector(1) should be set.
507 // In this case only the specified (last/last displayed) sector will be processed.
509 // If GetProcNextEvent()==0 the same event will be processed again
513 Int_t retflag = 0; // id of last sector + 1000, or error flag
514 if(GetProcNextEvent()==1 && fLastEv) { AliInfo("Last event already processed"); }
515 if(GetProcNextEvent()==1) ResetSectorArray();
518 if(GetProcNextEvent()==0 || GetProcOneSector()==1 ) sectorid = GetLastSector();
522 retflag = ReadData(sectorid);
524 SetLastProcFile(GetFile());
526 if(retflag>=10 && retflag<1000){ AliError("Could not read event properly: Check file name and format or try next event"); return 0 ;}
531 if(sectorid==-1 && retflag >1000)
533 AliInfo("Second read cycle");
535 if(GetLastSectorDisplayed()==-1) {sectorid = GetLastSector() ; }
536 else {sectorid = GetLastSectorDisplayed(); SetLastSector(sectorid) ; }
537 retflag = ReadData(sectorid);
540 SetLastSectorDisplayed(sectorid) ;
541 fMapHand->ReadfecHwMap(GetLastSector());
544 SetEventProcessed(1);
548 //__________________________________________________________________
549 Int_t AliTPCMonitor::ReadData(Int_t secid)
551 // Read Data File/Stream for specified Format.
552 // Payload will be extracted from either ROOT or DATE format
553 // and passed to FillHistsDecode for decoding of the adc information
555 Int_t format = GetFormat();
558 //if(format==2 && !gSystem->Getenv("DATE_ROOT")) { AliError("DATE not initialized on this system"); return 11;}
560 if( format==0) {return ReadDataROOT(secid);}
561 else if(format==1) {return ReadDataDATEFile(secid);}
564 return ReadDataDATEStream(secid);
567 AliWarning("Function should already be left");
570 //__________________________________________________________________
571 Int_t AliTPCMonitor::ReadDataDATEFile(Int_t secid)
573 // Read Data in Date format.
574 // Date file and monitor will be handled in this function.
576 if(fReaderROOT) { delete fReaderROOT ; fReaderROOT=0;}
579 if(fReaderDATEMon) { delete fReaderDATEMon ; fReaderDATEMon=0;}
582 Char_t* eventPtr = 0;
583 AliTPCMonitorDateFormat* dateform = 0;
586 if( fReaderDATE==0 || ( fReaderDATE!=0 && (strcmp(GetLastProcFile(),GetFile())!=0) ) )
588 cout << " Create new DATE file "<< endl;
589 if(fReaderDATE) { delete fReaderDATE ; fReaderDATE=0; }
590 fReaderDATE = new AliTPCMonitorDateFile() ;
591 fReaderDATE->SetName("fReaderDATE") ;
592 fReaderDATE->OpenDateFile(GetFile()) ;
596 // Get Event pointer ///
597 if(fReaderDATE->IsDateFileOpen() ==false ) { AliError("Could not open Date File"); return 11 ; }
598 // Rewind event if new event number is smaller than old one
599 if(fEventNumberOld>fEventNumber ) { fReaderDATE->ResetFilePos(); }
600 while(GetProcNextEvent() || fEventNumber==0)
602 fReaderDATE->ReadEvent();
603 eventPtr = fReaderDATE->GetMemoryPointer();
604 dateform = new AliTPCMonitorDateFormat(eventPtr);
605 Int_t currentev = dateform->GetEventID();
606 if(fEventNumber <= currentev ){ break; }
609 eventPtr = fReaderDATE->GetMemoryPointer();
611 if(dateform==0) dateform = new AliTPCMonitorDateFormat(eventPtr);
612 fEventNumber = dateform->GetEventID();
613 fEventNumberOld = dateform->GetEventID();
615 if(fReaderDATE->IsLastEvent()) fLastEv =1;
616 if(dateform->IsEventEndOfRun()) { AliInfo("Event is end of run: eventType END_OF_RUN "); }
618 if(fReaderDATE->IsEventValid() == false ) {AliInfo("Skipping Event because invalid"); return 10; }
619 if(dateform->IsEventPhysicsEvent() == false ) {AliInfo("Skipping Header/event because not Physics event"); return 12; }
623 Int_t lastrcu = ReadDataDATESubEventLoop(dateform,secid);
626 if(fVerb) cout << " last rcu " << lastrcu << endl;
632 //__________________________________________________________________
633 Int_t AliTPCMonitor::ReadDataDATEStream(Int_t secid)
635 // Read Data from DATE stream.
636 // Can also be used for DATE file.
639 if(fReaderROOT) { delete fReaderROOT ; fReaderROOT=0;}
640 if(fReaderDATE) { delete fReaderDATE ; fReaderDATE =0; }
642 Char_t* eventPtr = 0;
644 AliTPCMonitorDateFormat* dateform =0 ;
646 // Create objects ///
647 if((fReaderDATEMon==0 || ( fReaderDATEMon!=0 && (strcmp(GetLastProcFile(),GetFile())!=0) )))
649 if(fReaderDATEMon!=0)
651 fReaderDATEMon->Logout();
652 delete fReaderDATEMon;
654 fReaderDATEMon = new AliTPCMonitorDateMonitor();
655 fReaderDATEMon->SetName("DMon");
656 Int_t status = fReaderDATEMon->OpenMonitoring(GetFile());
657 if(status) { AliError(Form("Could not read event online: Error: %s",fReaderDATEMon->DecodeError(status))); return 11; }
660 if(GetProcNextEvent())
662 fReaderDATEMon->Free();
663 Int_t status = fReaderDATEMon->GetEvent();
664 if(status) { AliError(Form("Could not read event online: Error: %s",fReaderDATEMon->DecodeError(status))); return 11 ;}
665 //fReaderDATEMon->Logout();
668 eventPtr = fReaderDATEMon->GetEventPointerasChar();
670 if(dateform==0) dateform = new AliTPCMonitorDateFormat(eventPtr);
671 fEventNumber = dateform->GetEventID();
672 fEventNumberOld = dateform->GetEventID();
674 if(dateform->IsEventEndOfRun()) { AliInfo("Event is end of run: eventType END_OF_RUN "); }
675 if(dateform->IsEventPhysicsEvent() == false ) {AliInfo("Skipping Header/event because not Physics event"); return 12; }
679 Int_t lastrcu = ReadDataDATESubEventLoop(dateform,secid);
682 if(fVerb) cout << " last rcu " << lastrcu << endl;
686 //__________________________________________________________________
687 Int_t AliTPCMonitor::ReadDataDATEStream(Int_t /*secid*/)
689 // Read Data from DATE stream.
690 // Can also be used for DATE file.
691 // In case DATE is not install
692 // this method is dummy
694 AliError("DATE not initialized on this system");
699 Int_t AliTPCMonitor::ReadDataDATESubEventLoop(AliTPCMonitorDateFormat* dateform, Int_t secid)
701 // Loop over DATE Subevents
703 Bool_t exitSubEventLoop = false;
708 Char_t* eventPtr = 0;
709 UInt_t* eventPtrUI = 0;
713 while(exitSubEventLoop == false)
715 if(start==1) { dateform->GotoSubEventHeader() ; start=0;}
716 else { dateform->GotoNextSubEventHeader(); }
717 if(dateform->IsLastSubEventHeader()) exitSubEventLoop = true;
719 if(fVerb) cout << " next subevent LDC " << (Int_t)dateform->GetSubEventLDC() << endl;
726 if(neq ==0){ dateform->GotoFirstEquipment();}
727 else { dateform->GotoNextEquipment();}
729 fGdcId = dateform->GetSubEventGDC() ;
730 fLdcId = dateform->GetSubEventLDC();
731 fRunId = dateform->GetEventRunID();
732 fEqId = dateform->GetEquipmentID();
733 rcupatch = GetRCUPatch(fRunId, fEqId);
734 lastrcuid = (rcupatch+1000);
737 if(fLdcIdOld!=fLdcId && fChannelIter!=0) {
740 FillGlobal(GetLastSector());
752 if(dateform->IsLastEquipment() != false ) lasteq = 1;
754 eventPtr = dateform->GetFirstDataPointer();
755 eventPtrUI = (UInt_t *) eventPtr;
756 Int_t payload = dateform->GetPayloadSize(); // 40Bit words
758 if(fVerb)DumpHeader(dateform);
759 if(fVerb) cout << "Check sector and fEqId " << endl;
761 if(fVerb && secid >0 )
763 cout << "secid : "<< secid << " fEqId "<< fEqId << " equipment 0 form map " << endl;
764 cout << fMapEqidsSec[secid][0] << endl;
765 cout << " showed map_eqids " << endl;
768 if(CheckEqId(secid,fEqId))
770 if(fVerb) cout << " init altro " << endl;
771 AliTPCMonitorAltro* altro = new AliTPCMonitorAltro((UInt_t *)eventPtrUI,(payload/4),1); //hier
772 altro->SetWrite10Bit(GetWrite10Bit());
773 altro->SetActFilename(GetFile());
774 if(fVerb) cout << " allocated 10bit " << endl;
775 altro->Allocate10BitArray();
776 altro->Decodeto10Bit(fEqId);
777 AliInfo(Form("Process eqid %i , patch %i ",fEqId,rcupatch%6));
778 FillHistsDecode(altro,(rcupatch%6),secid);
779 if(fChannelIter!=0 && secid==-1 ) SetSectorFilled(rcupatch/6);
783 SetLastSector(rcupatch/6);
785 if(fChannelIter!=0 && secid==-1){ FillGlobal(GetLastSector()); }
789 //__________________________________________________________________
790 Int_t AliTPCMonitor::ReadDataROOT(Int_t secid)
792 // Read in data in ROOT format
793 if(fReaderDATE){ delete fReaderDATE ; fReaderDATE=0;}
797 Int_t equipmentSize = 0;
798 UChar_t* eventPtr = 0 ;
799 UInt_t* eventPtrUI = 0 ;
802 if(fReaderROOT==0 || ( fReaderROOT!=0 && (strcmp(GetLastProcFile(),GetFile())!=0) ) )
804 if(fVerb) cout << "AliTPCMonitor::ReadDataROOT create new reader " << endl;
805 if(fReaderROOT) { delete fReaderROOT ; fReaderROOT=0; }
806 fReaderROOT = new AliRawReaderRoot(GetFile());
807 if(!fReaderROOT) { AliError("Could not initiate AliRawReaderRoo "); return 10;}
811 // reset to beginning of the event
812 fReaderROOT->Reset();
814 // Rewind event if new event number is smaller than old one
815 if(fEventNumberOld>fEventNumber) fReaderROOT->RewindEvents();
817 while(GetProcNextEvent() || fEventNumber==0)
819 if(fVerb) cout << "AliTPCMonitor::ReadDataROOT get event " << endl;
820 if(!fReaderROOT->NextEvent()) { AliError("Could not get next Event"); return 11 ;}
821 // Int_t currentev = *(fReaderROOT->GetEventId());
823 Int_t currentev=fReaderROOT->GetEventIndex();
825 // skip all events but physics, calibration and software trigger events!
826 UInt_t eventType=fReaderROOT->GetType();
827 if ( !(eventType==AliRawEventHeaderBase::kPhysicsEvent ||
828 eventType==AliRawEventHeaderBase::kCalibrationEvent ||
829 eventType==AliRawEventHeaderBase::kSystemSoftwareTriggerEvent ||
830 eventType==AliRawEventHeaderBase::kDetectorSoftwareTriggerEvent) ) {
831 if (fVerb) cout<< "Skipping event! Its neither of 'physics, calibration and software trigger event'" << endl;
834 if(fEventNumber <= currentev ){ break; }
837 // fEventNumber = *(fReaderROOT->GetEventId());
838 // fEventNumberOld = *(fReaderROOT->GetEventId());
839 fEventNumber = fReaderROOT->GetEventIndex();
840 fEventNumberOld = fReaderROOT->GetEventIndex();
844 while(fReaderROOT->ReadHeader())
846 if(fVerb) cout << "AliTPCMonitor::ReadDataROOT read header " << endl;
847 fGdcId = fReaderROOT->GetGDCId() ;
848 fLdcId = fReaderROOT->GetLDCId() ;
849 fRunId = fReaderROOT->GetRunNumber() ;
850 equipmentSize = fReaderROOT->GetEquipmentSize();
851 fEqId = fReaderROOT->GetEquipmentId();
852 evtype = fReaderROOT->GetType();
853 rcupatch = GetRCUPatch(fRunId, fEqId);
854 lastrcuid = (rcupatch+1000);
856 if(evtype==1) { AliWarning(Form("EventType==1 in event %i ",fEventNumber)); return 10; }
857 if(equipmentSize==0) { AliWarning(Form("Equipmentsize ==0 in event %i ",fEventNumber)); return 10; }
859 if(fVerb) DumpHeader(fReaderROOT);
861 if(fLdcIdOld!=fLdcId && fChannelIter!=0) {
864 FillGlobal(GetLastSector());
875 if(CheckEqId(secid,fEqId))
877 fReaderROOT->ReadNextData(eventPtr);
878 eventPtrUI = (UInt_t *) eventPtr;
880 Int_t fsize = (Int_t)((equipmentSize/4) -offset) +1;
881 AliTPCMonitorAltro* altro = new AliTPCMonitorAltro((UInt_t *)eventPtrUI,fsize,2);
882 altro->SetWrite10Bit(GetWrite10Bit());
883 if(fVerb) cout << "AliTPCMonitor::ReadDataROOT Set Write10bit to " << GetWrite10Bit() << endl;
884 altro->SetActFilename(GetFile());
885 altro->Allocate10BitArray();
886 altro->Decodeto10Bit(fEqId);
887 AliInfo(Form("Process sector %i eqid %i , patch %i ",rcupatch/6,fEqId,rcupatch%6));
888 FillHistsDecode(altro,(rcupatch%6),secid);
889 if(fChannelIter!=0 && secid==-1 ) SetSectorFilled(rcupatch/6);
892 SetLastSector(rcupatch/6);
894 if(fChannelIter!=0 && secid==-1) { FillGlobal(GetLastSector()); }
899 //____________________________________________________________________________
900 void AliTPCMonitor::FillHistsDecode(AliTPCMonitorAltro* altro ,Int_t rcupatch, Int_t secid)
902 // Decode Channels, calculate base mean and rms depending on the
903 // value of secid (see ProcessEvent) and fill histograms
906 if(fVerb) cout << "FillHistsDecode : rcupatch " << rcupatch << " id " << secid << endl;
908 Int_t sampleiter = 0;
909 Int_t samplelength = 0;
910 Int_t samplebins = 0;
918 Int_t nextHwAddress = 0;
922 Int_t lastpos = altro->Get10BitArraySize()-1;
923 Short_t* entries = altro->Get10BitArray();
925 Double_t hmean = 0.0;
926 Int_t supnextpos = 0;
927 // TH1D* hbase = new TH1D("hbase","hbase",GetTimeBins(),0.5,(GetTimeBins()+0.5));
933 nextpos = altro->DecodeTrailer(lastpos);
934 supnextpos = altro->GetNextTrailerPos();
935 if(nextpos==-1) { break; }
936 Int_t itimebin=0; //timebins in this pad
939 blockpos = altro->GetTrailerBlockPos();
940 hw = altro->GetTrailerHwAddress();
941 nwords = altro->GetTrailerNWords();
942 nextHwAddress = ( hw + (rcupatch<<12) );
943 fPad[fChannelIter][0] = nextHwAddress ;
945 if(fPadMapHw[nextHwAddress]!=-1 )
947 //Int_t hw_before1 = fPad[fChannelIter-2][0];
948 //Int_t hw_before2 = fPad[fChannelIter-3][0];
950 if(fVerb){ cout <<"\n //// Ambiguous hwaddress " << nextHwAddress << " write 10bit files and check file for eqid : " << fEqId << " /////// " << endl;}
953 if( TMath::Abs(fPadMapRCU[nextHwAddress][4] - fChannelIter)==1)
955 if(fVerb) cout << "//// Difference to previous channel==1 : reset branch bit of hw from last channel to 1 " << endl;
956 Int_t hwreset = (nextHwAddress + (1<<11));
957 fPad[fChannelIter-1][0] = hwreset;
959 fPadMapHw[hwreset] = fChannelIter-1 ;
960 fPadMapRCU[hwreset][0]= rcupatch ;
961 fPadMapRCU[hwreset][1]= ((hwreset & AliTPCMonitorAltro::GetHwMaskBranch()) >> 11);
962 fPadMapRCU[hwreset][2]= ((hwreset & AliTPCMonitorAltro::GetHwMaskFEC()) >>7 );
963 fPadMapRCU[hwreset][3]= ( hwreset & AliTPCMonitorAltro::GetHwMaskFECChannel() );
964 fPadMapRCU[hwreset][4]= fChannelIter-1;
965 fPadMapRCU[hwreset][5]= altro->GetTrailerPos();
969 fPadMapHw[nextHwAddress] = fChannelIter ;
970 fPadMapRCU[nextHwAddress][0]= rcupatch ;
971 fPadMapRCU[nextHwAddress][1]= ((nextHwAddress & AliTPCMonitorAltro::GetHwMaskBranch())>> 11) ;
972 fPadMapRCU[nextHwAddress][2]= ((nextHwAddress & AliTPCMonitorAltro::GetHwMaskFEC()) >>7);
973 fPadMapRCU[nextHwAddress][3]= (nextHwAddress & AliTPCMonitorAltro::GetHwMaskFECChannel());
974 fPadMapRCU[nextHwAddress][4]= fChannelIter;
975 fPadMapRCU[nextHwAddress][5]= altro->GetTrailerPos();
989 for(Int_t iterwords = 0 ; iterwords< nwords ; iterwords++)
991 if(entries[blockpos-iterwords]==682) { continue; }
992 if(entries[blockpos-iterwords]!=682 && sampleiter==0)
994 samplelength = entries[blockpos-iterwords];
995 sampleiter = samplelength;
997 timestamp = entries[blockpos-iterwords-1];
1003 ntime = timestamp-samplebins;
1004 adc = entries[blockpos-iterwords];
1005 fPad[fChannelIter][ntime] = adc;
1006 //if( (adc!=0) && (ntime>=GetRangeBaseMin() ) && (ntime<GetRangeBaseMax() )) {hbase->Fill(adc) ;}
1007 if( (adc!=0) && (ntime>=GetRangeBaseMin() ) && (ntime<GetRangeBaseMax() )) {fbase[itimebin]=adc;itimebin++;}
1008 if( (adc>max) && (ntime>=GetRangeMaxAdcMin()) && (ntime<GetRangeMaxAdcMax() )) {max = adc;maxx = ntime ;}
1009 if( (ntime>=GetRangeSumMin()) && (ntime<GetRangeSumMax() )) {sum+=adc; sumn++;}
1015 // hmean = hbase->GetMean();
1016 // hbase->GetXaxis()->SetRangeUser(hmean- hmean/3 , hmean + hmean/3);
1017 // hmean = hbase->GetMean();
1018 // hrms = hbase->GetRMS();
1020 hmean = TMath::Mean(itimebin, fbase);
1021 hrms = TMath::RMS(itimebin, fbase);
1024 if( GetPedestals()==1) fHistAddrMaxAdc->SetBinContent( nextHwAddress,max- hmean);
1025 else fHistAddrMaxAdc->SetBinContent( nextHwAddress,max );
1031 fHistDistrBase2dIROC->Fill(hmean,hrms);
1032 fHistDistrSumIROC->Fill(sum);
1033 if( GetPedestals()==1 ) { fHistDistrMaxIROC->Fill(max-hmean); fHistDistrSumIROC->Fill(sum -sumn*hmean);}
1034 else { fHistDistrMaxIROC->Fill(max); fHistDistrSumIROC->Fill(sum );}
1038 fHistDistrBase2dOROC->Fill(hmean,hrms);
1039 fHistDistrSumOROC->Fill(sum);
1040 if( GetPedestals()==1 ){ fHistDistrMaxOROC->Fill(max-hmean); fHistDistrSumOROC->Fill(sum -sumn*hmean);}
1041 else { fHistDistrMaxOROC->Fill(max); fHistDistrSumOROC->Fill(sum) ;}
1044 fHistAddrAdcSum->SetBinContent( nextHwAddress,sum);
1045 fHistAddrMapIndex->SetBinContent(nextHwAddress,fChannelIter);
1046 fHistAddrBaseMean->SetBinContent(nextHwAddress,hmean);
1047 fHistAddrMaxAdcX->SetBinContent( nextHwAddress,maxx);
1048 fHistAddrBaseRms->SetBinContent( nextHwAddress,hrms);
1051 if(nextpos<0) { AliError("Error : next pos < 0 "); break ;}
1058 //____________________________________________________________________________
1059 void AliTPCMonitor::FillHistsPadPlane()
1061 // Fill 2Dim histograms for IROC and OROC (max , rms and sum)
1063 if(fVerb)cout << "AliTPCMonitor::FillHistsPadPlane() Start " << endl;
1064 if(fVerb)PrintConfig();
1071 for(Int_t ch = 0; ch<fChannelIter; ch++)
1074 fHistChannelTime->SetCellContent(ch,0,hwadd);
1076 for(Int_t bin = 1; bin <GetTimeBins(); bin++)
1078 if( fHistChannelTime->GetCellContent(ch,bin)!=0) cout << " cellcontent already set " << endl;
1079 if( GetPedestals()==1 ) fHistChannelTime->SetCellContent(ch,bin,(fPad[ch][bin]- fHistAddrBaseMean->GetBinContent(hwadd)));
1080 else fHistChannelTime->SetCellContent(ch,bin,(fPad[ch][bin]));
1083 pad = fMapHand->GetPad( hwadd);
1084 row = fMapHand->GetPadRow(hwadd);
1085 padmax = fMapHand->GetNumofPads(row);
1089 fHistIROC->SetCellContent( row +1 ,pad +55 -padmax/2 +1,fHistAddrMaxAdc->GetBinContent( hwadd));
1090 fHistIROCIndex->SetCellContent(row +1 ,pad +55 -padmax/2 +1,ch);
1091 fHistIROCRMS->SetCellContent( row +1 ,pad +55 -padmax/2 +1,fHistAddrBaseRms->GetBinContent( hwadd));
1092 fHistIROCBASE->SetCellContent( row +1 ,pad +55 -padmax/2 +1,fHistAddrBaseMean->GetBinContent(hwadd));
1093 fHistIROCSUM->SetCellContent( row +1 ,pad +55 -padmax/2 +1,fHistAddrAdcSum->GetBinContent( hwadd));
1097 fHistOROC->SetCellContent( row-63 +1 ,pad +70 -padmax/2 +1,fHistAddrMaxAdc->GetBinContent( hwadd));
1098 fHistOROCIndex->SetCellContent(row-63 +1 ,pad +70 -padmax/2 +1,ch);
1099 fHistOROCRMS->SetCellContent( row-63 +1 ,pad +70 -padmax/2 +1,fHistAddrBaseRms->GetBinContent( hwadd));
1100 fHistOROCBASE->SetCellContent( row-63 +1 ,pad +70 -padmax/2 +1,fHistAddrBaseMean->GetBinContent(hwadd));
1101 fHistOROCSUM->SetCellContent( row-63 +1 ,pad +70 -padmax/2 +1,fHistAddrAdcSum->GetBinContent( hwadd));
1105 fHistChannelTime->GetXaxis()->SetRange(0,fChannelIter);
1106 fHistChannelTime->GetYaxis()->SetRange(0,GetTimeBins());
1111 //____________________________________________________________________________
1112 void AliTPCMonitor::ResetArrays()
1114 // Reset data arrays
1115 for(Int_t row = 0 ; row < fkNRowsIroc; row++)
1117 for(Int_t pad = 0 ; pad < fkNPadsIroc ; pad++)
1119 fHistIROCIndex->SetCellContent(row+1,pad+1,-1);
1122 for(Int_t row = 0 ; row < fkNRowsOroc; row++)
1124 for(Int_t pad = 0 ; pad < fkNPadsOroc ; pad++)
1126 fHistOROCIndex->SetCellContent(row+1,pad+1,-1);
1130 for(Int_t ch= 0; ch<GetMaxHwAddr(); ch++)
1132 fHistAddrMaxAdcX->SetBinContent(ch,-1);
1133 fHistAddrMapIndex->SetBinContent(ch,-1);
1134 fHistAddrMaxAdc->SetBinContent( ch, 0);
1135 fHistAddrBaseMean->SetBinContent( ch, 0);
1136 fHistAddrAdcSum->SetBinContent( ch, 0);
1137 fHistAddrBaseRms->SetBinContent(ch, 0);
1140 for(Int_t ch = 0; ch< GetNumOfChannels(); ch++)
1142 for(Int_t bin = 0; bin< GetTimeBins(); bin++)
1147 for(Int_t ch = 0; ch< GetMaxHwAddr(); ch++)
1150 fPadMapRCU[ch][0]=-1;
1151 fPadMapRCU[ch][1]=-1;
1152 fPadMapRCU[ch][2]=-1;
1153 fPadMapRCU[ch][3]=-1;
1154 fPadMapRCU[ch][4]=-1;
1155 fPadMapRCU[ch][5]=-1;
1161 //____________________________________________________________________________
1162 void AliTPCMonitor::ResetHistos()
1165 for(Int_t i =0; i<fHistList->GetEntries(); i++)
1167 if(GetProcNextEvent()==0 && strcmp(((TH1*)fHistList->At(i))->GetName(),"SIDE A")==0) continue;
1168 if(GetProcNextEvent()==0 && strcmp(((TH1*)fHistList->At(i))->GetName(),"SIDE C")==0) continue;
1169 ((TH1*)fHistList->At(i))->Reset();
1174 //____________________________________________________________________________
1175 void AliTPCMonitor::DeleteHistos()
1177 // Delete histograms
1178 for(Int_t i =0; i<fHistList->GetEntries(); i++)
1180 delete (TH1*)fHistList->At(i);
1185 //__________________________________________________________________
1186 Int_t AliTPCMonitor::CheckEqId(Int_t secid,Int_t eqid)
1188 // Check if equipment id corresponds to any rcu patch in sector
1189 // Equipment ids changed during commisioning in 2006 (starting from run 704)
1190 // However Runids started from 0 again in 2007
1191 // Now only runids from commissioning in 2006 after runid 704 and all new ones are supported.
1192 // Comment in equipment check for runids < 704 if old runs should be processed
1194 if(fVerb) cout << "AliTPCMonitor::CheckEqId : SectorId " << secid << " EquipmentId " << eqid << " runid " << fRunId << endl;
1196 //skip all eqids which do not belong to the TPC
1197 if ( eqid<768||eqid>983 ) return 0;
1199 if(fRunId<704 && 0) // commented out --> runs with runid < 704 in 2006 are not recognized anymore
1201 if( (secid>-1) && (secid<36) ) // if ( secid is in range) { take only specific eqids} else { take all }
1203 if( (secid==13) && ( eqid!=408 && eqid!=409 && eqid!=509 && eqid!=512 && eqid!=513 && eqid!=517 )) {passed=0;}
1204 else if( (secid==4) && ( eqid!=404 && eqid!=504 && eqid!=407 && eqid!=503 && eqid!=508 && eqid!=506 )) {passed=0;}
1206 else {if(fVerb) cout << "passed check "<< endl; }
1210 if( (secid>-1) && (secid<36) ) // if ( secid is in range) { take only specific eqids} else { take all }
1212 if(eqid!=fMapEqidsSec[secid][0] && eqid!= fMapEqidsSec[secid][1] && eqid!=fMapEqidsSec[secid][2] &&
1213 eqid!=fMapEqidsSec[secid][3] && eqid!= fMapEqidsSec[secid][4] && eqid!=fMapEqidsSec[secid][5] ) {passed=0;}
1215 else {if(fVerb) cout << "passed check "<< endl;}
1221 //__________________________________________________________________
1222 void AliTPCMonitor::SetEqIds()
1224 // Set mapping for equipment ids
1225 for(Int_t i = 0; i<36 ; i++)
1227 for(Int_t j = 0; j<6; j++)
1229 if(j<2) fMapEqidsSec[i][j]= 768+i*2+j;
1230 else fMapEqidsSec[i][j]= 840+i*4+j-2;
1234 for(Int_t i = 0; i<36 ; i++)
1236 for(Int_t j = 0; j<6; j++)
1238 if(j<2) fMapEqidsRcu[768+i*2+j] = i*6 +j;
1239 else fMapEqidsRcu[840+i*4+j-2] = i*6 +j;
1244 //__________________________________________________________________
1245 void AliTPCMonitor::FillGlobal(Int_t sector)
1248 // Fill global histograms with max adc for each channel
1251 if((sector/18) ==0) hglob = fHistGlobalMaxA;
1252 else hglob = fHistGlobalMaxC;
1254 Float_t rotsec = (2*TMath::Pi()/18.0);
1255 Float_t rot = (-rotsec*(sector%18) +4*rotsec);
1257 Float_t m11 = TMath::Cos(rot);
1258 Float_t m12 = TMath::Sin(rot);
1259 Float_t m21 = -1*TMath::Sin(rot);
1260 Float_t m22 = TMath::Cos(rot);
1262 Int_t max = 0; // use integer for global view
1264 Double_t xval = 0.0;
1265 Double_t yval = 0.0;
1274 for(Int_t hw = 0; hw<fHistAddrMaxAdc->GetNbinsX(); hw++)
1276 max = (Int_t)fHistAddrMaxAdc->GetBinContent(hw);
1279 pad = fMapHand->GetPad( hw);
1280 row = fMapHand->GetPadRow(hw);
1281 padmax = fMapHand->GetNumofPads(row);
1282 if (sector%36>17) fMirror=-1;
1284 GetXY(xval ,yval , padmax,row ,pad);
1285 xdr = xval*m11 +yval*m12;
1286 ydr = xval*m21 +yval*m22;
1287 if(hglob->GetBinContent(hglob->GetXaxis()->FindBin(xdr),hglob->GetYaxis()->FindBin(ydr))==0) hglob->Fill(xdr,ydr,(Int_t)max);
1293 //__________________________________________________________________
1294 void AliTPCMonitor::GetXY( Double_t& xval , Double_t& yval , Int_t padmax, Int_t row , Int_t pad) const
1296 // Get x and y position of pad
1300 xval = fMirror*( 2*padmax -4*pad -2);
1301 yval = 852.25 +7.5*row;
1305 xval = fMirror*( 3*padmax -6*pad -3);
1306 if((row-63)<63) { yval = 10*(row-63) +1351; }
1307 else { yval = 15*(row-63-64)+1993.5; }
1312 //__________________________________________________________________
1313 Int_t AliTPCMonitor::GetPadAtX(Float_t xval, Int_t row, Int_t padmax) const
1315 // Get pad number at given position in x
1318 if(row<63) {pad = (Int_t)( ( (xval/fMirror) +2 -2*padmax)/-4);}
1319 else {pad = (Int_t)( ( (xval/fMirror) +3 -3*padmax)/-6);}
1321 if(pad>=padmax) return -1;
1326 //__________________________________________________________________
1327 Int_t AliTPCMonitor::GetPadAtX(Float_t xval, Int_t row) const
1330 // Get pad number at given position in x
1332 Int_t padmax = fMapHand->GetNumofPads(row);
1335 if(row<63) {pad = (Int_t)( ( (xval/fMirror) +2 -2*padmax)/-4);}
1336 else {pad = (Int_t)( ( (xval/fMirror) +3 -3*padmax)/-6);}
1338 if(pad>=padmax) return -1;
1343 //__________________________________________________________________
1344 void AliTPCMonitor::DrawHists(Int_t histos)
1347 // Draw sets of histograms
1348 // histos==1 : 2Dim histos for MAX adc and add executables
1349 // histos==2 : distributions max/rms/sum
1350 // histos==3 : global max adc for specified SideA/C
1353 if(fVerb) cout << " Draw histos " << endl;
1355 if(GetLastSector()/18==0 ) sprintf(cside,"A");
1356 else sprintf(cside,"C");
1358 Char_t titleSEC[256]; sprintf(titleSEC ,"Sector %i Side %s Run : %05i EventID %i " ,GetLastSector()%18,cside,fRunId, fEventNumber);
1359 Char_t titleEvent[256]; sprintf(titleEvent ,"Time <-> Channles %s" ,titleSEC);
1360 Char_t titleIROC[256]; sprintf(titleIROC ,"IROC %s" ,titleSEC);
1361 Char_t titleOROC[256]; sprintf(titleOROC ,"OROC %s" ,titleSEC);
1363 Char_t titleMAX[256]; sprintf(titleMAX ,"Max (timebin: %i,%i) %s" ,GetRangeMaxAdcMin(),GetRangeMaxAdcMax(),titleSEC);
1364 Char_t titleSUM[256]; sprintf(titleSUM ,"Sum (timebin: %i,%i) %s" ,GetRangeSumMin() ,GetRangeSumMax() ,titleSEC);
1365 Char_t titleBASE[256]; sprintf(titleBASE ,"Baseline RMS<->Mean (timebin: %i-%i) %s" ,GetRangeBaseMin() ,GetRangeBaseMax() ,titleSEC);
1366 Char_t titleMEAN[256]; sprintf(titleMEAN ,"Baseline Mean (timebin: %i-%i) %s" ,GetRangeBaseMin() ,GetRangeBaseMax() ,titleSEC);
1367 Char_t titleRMS[256] ; sprintf(titleRMS ,"Baseline RMS (timebin: %i-%i) %s" ,GetRangeBaseMin() ,GetRangeBaseMax() ,titleSEC);
1371 // IROC _______________________________________________________________
1373 ciroc = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("ciroc");
1376 ciroc = CreateCanvas("ciroc");
1381 fHistIROC->SetXTitle("row");
1382 fHistIROC->SetYTitle("pad");
1383 if(GetPedestals()) fHistIROC->SetZTitle("max ADC (baseline sub)");
1384 else fHistIROC->SetZTitle("max ADC ");
1385 fHistIROC->SetTitle(titleIROC);
1386 fHistIROC->SetMinimum(0.01);
1387 fHistIROC->Draw("COLZ");
1388 ciroc->UseCurrentStyle();
1391 fHistIROCTime->SetXTitle("row"); fHistIROCTime->SetZTitle("peak time (fit)"); fHistIROCTime->SetYTitle("pad"); fHistIROCTime->SetTitle(titleIROC);
1392 fHistIROCRMS->SetXTitle("row"); fHistIROCRMS->SetZTitle( "baseline rms (ADC)"); fHistIROCRMS->SetYTitle("pad"); fHistIROCRMS->SetTitle(titleIROC);
1396 coroc =(TCanvas*)gROOT->GetListOfCanvases()->FindObject("coroc");
1398 coroc = CreateCanvas("coroc");
1403 fHistOROC->SetXTitle("row");
1404 fHistOROC->SetYTitle("pad");
1405 if(GetPedestals()) fHistOROC->SetZTitle("max ADC (baseline sub)");
1406 else fHistOROC->SetZTitle("max ADC ");
1407 fHistOROC->SetTitle(titleOROC);
1408 fHistOROC->SetMinimum(0.01);
1409 fHistOROC->Draw("COLZ");
1410 coroc->UseCurrentStyle();
1413 fHistOROCTime->SetXTitle("row"); fHistOROCTime->SetZTitle("peak time (fit) (timebins)"); fHistOROCTime->SetYTitle("pad"); fHistOROCTime->SetTitle(titleOROC);
1414 fHistOROCRMS->SetXTitle("row"); fHistOROCRMS->SetZTitle("baseline rms (ADC)"); fHistOROCRMS->SetYTitle("pad"); fHistOROCRMS->SetTitle(titleOROC);
1417 Char_t namesum[256] ; sprintf(namesum,"ADC sum (bins: %i, %i)",GetRangeSumMin() ,GetRangeSumMax() );
1418 fHistIROCSUM->SetXTitle("row"); fHistIROCSUM->SetZTitle(namesum); fHistIROCSUM->SetYTitle("pad"); fHistIROCSUM->SetTitle(titleIROC);
1419 fHistOROCSUM->SetXTitle("row"); fHistOROCSUM->SetZTitle(namesum); fHistOROCSUM->SetYTitle("pad"); fHistOROCSUM->SetTitle(titleOROC);
1422 Char_t namebase[256] ; sprintf(namebase ,"base mean (timbebin: %i, %i )",GetRangeBaseMin(),GetRangeBaseMax());
1423 fHistIROCBASE->SetXTitle("row"); fHistIROCBASE->SetZTitle(namebase); fHistIROCBASE->SetYTitle("pad"); fHistIROCBASE->SetTitle(titleIROC);
1424 fHistOROCBASE->SetXTitle("row"); fHistOROCBASE->SetZTitle(namebase); fHistOROCBASE->SetYTitle("pad"); fHistOROCBASE->SetTitle(titleOROC);
1426 if(fHistIROCClone) fHistIROCClone->Delete();
1427 if(fHistOROCClone) fHistOROCClone->Delete();
1428 fHistIROCClone = (TH2F*)fHistIROC->Clone("fHistIROCClone");
1429 fHistOROCClone = (TH2F*)fHistOROC->Clone("fHistOROCClone");
1432 if(fExecPlaneMax==0)
1435 sprintf(carry1,".x %s/TPC/AliTPCMonitorExec.C(1)",gSystem->Getenv("ALICE_ROOT"));
1436 ciroc->AddExec("pad",carry1);
1437 coroc->AddExec("pad",carry1);
1440 sprintf(carry2,".x %s/TPC/AliTPCMonitorExec.C(2)",gSystem->Getenv("ALICE_ROOT"));
1441 ciroc->AddExec("row",carry2);
1442 coroc->AddExec("row",carry2);
1450 // MAX ADC distribution ____________________________________________
1452 cmax = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("cmax");
1453 if(!cmax) cmax = CreateCanvas("cmax");
1456 fHistDistrMaxIROC->GetXaxis()->SetRangeUser(0.0,1000.0);
1457 fHistDistrMaxIROC->SetXTitle("max ADC (ADC)");
1458 fHistDistrMaxIROC->SetYTitle("counts");
1459 fHistDistrMaxIROC->SetTitle(titleMAX);
1460 fHistDistrMaxIROC->Draw("");
1461 fHistDistrMaxOROC->SetLineColor(2);
1462 fHistDistrMaxOROC->Draw("same");
1464 if(fHistDistrMaxOROC->GetMaximum()> fHistDistrMaxIROC->GetMaximum()) fHistDistrMaxIROC->SetMaximum(fHistDistrMaxOROC->GetMaximum()*1.1);
1466 TLegend* legio = new TLegend(0.6,0.6,0.8,0.8);
1467 legio->SetFillColor(0);
1468 legio->AddEntry(fHistDistrMaxIROC,"IROC","l");
1469 legio->AddEntry(fHistDistrMaxOROC,"OROC","l");
1470 legio->Draw("same");
1472 // ADC sum distribution
1474 csum = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("csum");
1475 if(!csum) csum = CreateCanvas("csum") ;
1478 fHistDistrSumIROC->SetXTitle("sum ADC (ADC)");
1479 fHistDistrSumIROC->SetYTitle("counts");
1480 fHistDistrSumIROC->SetTitle(titleSUM);
1481 fHistDistrSumIROC->Draw("");
1482 fHistDistrSumOROC->SetLineColor(2);
1483 fHistDistrSumOROC->Draw("same");
1484 if(fHistDistrSumOROC->GetMaximum()> fHistDistrSumIROC->GetMaximum()) fHistDistrSumIROC->SetMaximum(fHistDistrSumOROC->GetMaximum()*1.1);
1485 legio->Draw("same");
1487 // BASELINE MEAN distribution
1488 TCanvas* cbasemean = 0;
1489 cbasemean = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("cbasemean");
1490 if(!cbasemean) cbasemean = CreateCanvas("cbasemean");
1493 fHistDistrBaseMeanIROC = fHistDistrBase2dIROC->ProjectionX("fHistDistrBaseMeanIROC");
1494 fHistDistrBaseMeanIROC->SetXTitle("base mean (ADC)");
1495 fHistDistrBaseMeanIROC->SetYTitle("counts");
1496 fHistDistrBaseMeanIROC->SetTitle(titleMEAN);
1497 fHistDistrBaseMeanIROC->Draw("");
1499 fHistDistrBaseMeanOROC = fHistDistrBase2dOROC->ProjectionX("fHistDistrBaseMeanOROC");
1500 fHistDistrBaseMeanOROC->SetLineColor(2);
1501 fHistDistrBaseMeanOROC->Draw("same");
1502 if(fHistDistrBaseMeanOROC->GetMaximum()>fHistDistrBaseMeanIROC->GetMaximum()) fHistDistrBaseMeanIROC->SetMaximum(fHistDistrBaseMeanOROC->GetMaximum()*1.1);
1503 legio->Draw("same");
1505 TCanvas* cbaserms = 0;
1506 cbaserms = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("cbaserms");
1507 if(!cbaserms) cbaserms = CreateCanvas("cbaserms") ;
1510 // BASELINE RMS distribution
1511 fHistDistrBaseRmsIROC = fHistDistrBase2dIROC->ProjectionY("fHistDistrBaseRmsIROC");
1512 fHistDistrBaseRmsIROC->SetXTitle("base rms (ADC)");
1513 fHistDistrBaseRmsIROC->SetYTitle("counts");
1514 fHistDistrBaseRmsIROC->SetTitle(titleRMS);
1515 fHistDistrBaseRmsIROC->Draw("");
1517 fHistDistrBaseRmsOROC = fHistDistrBase2dOROC->ProjectionY("fHistDistrBaseRmsOROC");
1518 fHistDistrBaseRmsOROC->SetLineColor(2);
1519 fHistDistrBaseRmsOROC->Draw("same");
1520 if(fHistDistrBaseRmsOROC->GetMaximum()>fHistDistrBaseRmsIROC->GetMaximum()) fHistDistrBaseRmsIROC->SetMaximum(fHistDistrBaseRmsOROC->GetMaximum()*1.1);
1521 legio->Draw("same");
1525 cbasemean->Update();
1530 // GLOBAL MAX ADC _________________________________
1531 if(GetProcNextEvent()==1)
1536 if(!(cglobC=(TCanvas*)gROOT->GetListOfCanvases()->FindObject("SIDE C all"))) cglobC = CreateCanvas("SIDE C all");
1537 if(!(cglobA=(TCanvas*)gROOT->GetListOfCanvases()->FindObject("SIDE A all"))) cglobA = CreateCanvas("SIDE A all");
1539 Char_t globtitle1[256]; sprintf(globtitle1,"SIDE A Run %05i (EventID %i)",fRunId,fEventNumber);
1540 Char_t globtitle2[256]; sprintf(globtitle2,"SIDE C Run %05i (EventID %i)",fRunId,fEventNumber);
1542 fHistGlobalMaxA->SetTitle(globtitle1);
1543 fHistGlobalMaxC->SetTitle(globtitle2);
1544 fHistGlobalMaxA->SetXTitle("x/mm");
1545 fHistGlobalMaxA->SetYTitle("y/mm");
1546 fHistGlobalMaxC->SetXTitle("x/mm");
1547 fHistGlobalMaxC->SetYTitle("y/mm");
1549 if(GetPedestals()==0) { fHistGlobalMaxA->SetZTitle("max adc (not baseline sub)"); fHistGlobalMaxC->SetZTitle("max adc (not baseline sub)"); }
1550 else { fHistGlobalMaxA->SetZTitle("max adc "); fHistGlobalMaxC->SetZTitle("max adc "); }
1552 fHistGlobalMaxA->SetMinimum(0.01);
1553 fHistGlobalMaxC->SetMinimum(0.01);
1555 cglobC->cd() ; fHistGlobalMaxC->Draw("COLZ");
1556 cglobA->cd() ; fHistGlobalMaxA->Draw("COLZ");
1559 sprintf(nameom,".x %s/TPC/AliTPCMonitorExec.C(3)",gSystem->Getenv("ALICE_ROOT"));
1563 if(fVerb)cout << " set exec " << nameom << endl;
1564 cglobC->AddExec("glob",nameom);
1565 cglobA->AddExec("glob",nameom);
1570 cglobC->DeleteExec("glob");
1571 cglobA->DeleteExec("glob");
1573 if(fVerb) cout << " set exec " << nameom << endl;
1574 cglobC->AddExec("glob",nameom);
1575 cglobA->AddExec("glob",nameom);
1587 //__________________________________________________________________
1588 void AliTPCMonitor::DrawRMSMap()
1590 // Draw 2Dim rms histos for IROC and OROC
1591 // and set executables for canvases
1593 TCanvas* crmsoroc =0;
1594 TCanvas* crmsiroc =0;
1595 if(!(crmsoroc = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("crmsoroc"))) crmsoroc = CreateCanvas("crmsoroc");
1596 if(!(crmsiroc = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("crmsiroc"))) crmsiroc = CreateCanvas("crmsiroc");
1598 crmsiroc->cd(); fHistIROCRMS->Draw("COLZ");
1599 crmsoroc->cd(); fHistOROCRMS->Draw("COLZ");
1601 Char_t carry1[100]; sprintf(carry1,".x %s/TPC/AliTPCMonitorExec.C(1)",gSystem->Getenv("ALICE_ROOT"));
1602 Char_t carry2[100]; sprintf(carry2,".x %s/TPC/AliTPCMonitorExec.C(2)",gSystem->Getenv("ALICE_ROOT"));
1604 if(fExecPadIrocRms==0)
1606 crmsiroc->AddExec("pad",carry1);
1607 crmsiroc->AddExec("row",carry2);
1611 if(fExecPadOrocRms==0)
1613 crmsoroc->AddExec("pad",carry1);
1614 crmsoroc->AddExec("row",carry2);
1625 //__________________________________________________________________
1626 void AliTPCMonitor::ExecPad()
1629 // Executable for Pad
1630 // Show time profile for channel the mouse is pointing at
1632 Int_t event = gPad->GetEvent();
1633 if (event != 51) return;
1635 TObject *select = gPad->GetSelected();
1637 if(!select->InheritsFrom("TH2")) { return; }
1638 gPad->GetCanvas()->FeedbackMode(kTRUE);
1641 Int_t px = gPad->GetEventX();
1642 Int_t py = gPad->GetEventY();
1643 Float_t upy = gPad->AbsPixeltoY(py);
1644 Float_t upx = gPad->AbsPixeltoX(px);
1645 Float_t y = gPad->PadtoY(upy);
1646 Float_t x = gPad->PadtoX(upx);
1651 // Char_t namehist[50];
1652 Char_t projhist[60];
1653 Char_t namesel[256];
1654 Char_t namecanv[256];
1658 Float_t ybinmin = 0;
1659 Float_t ybinmax = 0;
1662 // Check wich Canvas executed the event
1664 sprintf(namesel,select->GetName());
1665 if(strcmp(namesel,"fHistOROC")==0 || strcmp(namesel,"fHistOROCRMS")==0 || strcmp(namesel,"fHistOROCTime")==0 )
1669 sprintf(projhist,"ProjectionOROC");
1670 sprintf(namecanv,"coroc_ch");
1671 fHistIndex = fHistOROCIndex;
1673 if(strcmp(namesel,"fHistIROC")==0 || strcmp(namesel,"fHistIROCRMS")==0 || strcmp(namesel,"fHistIROCTime")==0 )
1677 sprintf(projhist,"ProjectionIROC");
1678 sprintf(namecanv,"ciroc_ch");
1679 fHistIndex = fHistIROCIndex;
1682 // Check if Canvas already existed and get Ranges from former Prjection histogram
1683 if((cpad=(TCanvas*)gROOT->GetListOfCanvases()->FindObject(namecanv)))
1686 if(gROOT->Get(projhist))
1689 xbinmin = ((TH1D*)gROOT->Get(projhist))->GetXaxis()->GetFirst();
1690 xbinmax = ((TH1D*)gROOT->Get(projhist))->GetXaxis()->GetLast();
1691 ybinmin = ((TH1D*)gROOT->Get(projhist))->GetMinimum();
1692 ybinmax = ((TH1D*)gROOT->Get(projhist))->GetMaximum();
1693 delete gROOT->Get("legfit");
1694 delete gROOT->Get("fg");
1699 cpad = CreateCanvas(namecanv); cpad->cd();
1703 Int_t testy = fHistIndex->GetYaxis()->FindBin(y);
1704 Int_t testx = fHistIndex->GetXaxis()->FindBin(x);
1705 Int_t binchannel = (Int_t)fHistIndex->GetCellContent(testx,testy);
1706 if(binchannel>30000 || binchannel<0) return;
1708 if(gROOT->Get(projhist)) delete gROOT->Get(projhist);
1710 TH1D *hp = (TH1D*)(((TH1D*)fHistChannelTime->ProjectionY("hp",binchannel,binchannel))->Clone(projhist));
1712 // Make title and Pave for channel Info
1714 Int_t npadRow , npad , nhw , nmax , hwadd;
1716 hwadd = (Int_t)fHistChannelTime->GetCellContent(binchannel,0);
1717 fPadUsedHwAddr = hwadd;
1719 if(rocid==0)npadRow = fMapHand->GetPadRow(hwadd);
1720 else npadRow = fMapHand->GetPadRow(hwadd)-63;
1721 npad = fMapHand->GetPad(hwadd);
1723 nmax = (Int_t)hp->GetMaximum();
1726 TPaveText* legstat = new TPaveText(0.18,0.65,0.3,0.8,"NDC");
1728 Int_t connector = fMapHand->GetFECconnector(hwadd);
1729 Int_t fecnr = fMapHand->GetFECfromHw(hwadd);
1730 Int_t fecch = fMapHand->GetFECchannel(hwadd);
1731 Int_t altrochip = fMapHand->GetAltro(hwadd);
1732 Int_t altrochannel= (fMapHand->GetAltroChannel(hwadd))%16;
1733 Int_t fecloc = fMapHand->U2fGetFECinRCU(fecnr) ;
1734 Int_t feclocbran = fMapHand->U2fGetFECinBranch(fecnr);
1735 Int_t branch = fMapHand->U2fGetBranch(fecnr);
1738 Short_t fecget = (hwadd & AliTPCMonitorAltro::GetHwMaskFEC()) >> 7;
1739 Short_t branchget = (hwadd & AliTPCMonitorAltro::GetHwMaskBranch())>> 11;
1742 Char_t nstat1[100]; Char_t nstat2[100]; Char_t nstat3[100]; Char_t nstat4[100];
1743 Char_t nstat5[100]; Char_t nstat6[100]; Char_t nstat7[100]; Char_t nstat8[100];
1745 sprintf(nstat1,"Branch (map) \t %i (%i) \n",branchget,branch);
1746 sprintf(nstat2,"Fec in patch \t %i \n",fecloc);
1747 sprintf(nstat8,"Fec in branch (map)\t %i (%i)\n",fecget,feclocbran);
1748 sprintf(nstat7,"Connector \t %i \n",connector);
1749 sprintf(nstat3,"Fec No. \t %i \n",fecnr);
1750 sprintf(nstat4,"Fec chan \t %i \n",fecch);
1751 sprintf(nstat5,"Altro chip\t %i \n",altrochip);
1752 sprintf(nstat6,"Altro chan\t %i \n",altrochannel);
1754 legstat->AddText(nstat1); legstat->AddText(nstat2); legstat->AddText(nstat8); legstat->AddText(nstat7);
1755 legstat->AddText(nstat3); legstat->AddText(nstat4); legstat->AddText(nstat5); legstat->AddText(nstat6);
1757 sprintf(title,"Row=%d Pad=%d Hw =%d maxADC =%d count =%d",npadRow,npad,nhw,nmax,binchannel);
1759 hp->SetName(projhist);
1760 hp->SetTitleSize(0.04);
1761 hp->SetTitle(title);
1762 hp->SetYTitle("ADC");
1763 hp->SetXTitle("Timebin");
1764 hp->GetXaxis()->SetTitleColor(1);
1768 hp->GetXaxis()->SetRange(xbinmin,xbinmax);
1769 hp->SetMinimum(ybinmin);
1770 hp->SetMaximum(ybinmax);
1774 hp->SetMinimum(0.0);
1775 hp->SetMaximum(1000.0);
1782 if(GetPedestals() && fDisableFit==0)
1784 Int_t maxx = (Int_t)fHistAddrMaxAdcX->GetBinContent(hwadd);
1785 Float_t max = (Float_t)fHistAddrMaxAdc->GetBinContent(hwadd);
1786 Float_t base = (Float_t)fHistAddrBaseMean->GetBinContent(hwadd);
1789 if( ((max+base)/base)>1.2)
1791 TF1* fg = new TF1("fg",AliTPCMonitor::Gamma4,maxx-5,maxx+5,4);
1792 fg->SetParName(0,"Normalisation");
1793 fg->SetParName(1,"Minimum");
1794 fg->SetParName(2,"Width");
1795 fg->SetParName(3,"Base");
1796 fg->SetParameter(0,max);
1797 fg->SetParameter(1,maxx-2);
1798 fg->SetParameter(2,1.5);
1799 fg->FixParameter(3,0);
1800 fg->SetLineColor(4);
1801 fg->SetLineWidth(1);
1804 TLegend* legfit = new TLegend(0.6,0.7,0.7,0.8);
1805 legfit->AddEntry("fg","#Gamma 4 fit","l");
1806 legfit->SetFillColor(0);
1807 legfit->SetName("legfit");
1808 legfit->Draw("same");
1812 legstat->SetFillColor(0);
1813 legstat->Draw("same");
1818 //__________________________________________________________________
1819 void AliTPCMonitor::ExecRow()
1822 // Executable for Pad
1823 // Show profile of max adc over given pad row
1824 // and 2dim histo adc(pad-in-row,time bin)
1826 Int_t event = gPad->GetEvent();
1827 if (event != 61) return;
1829 TObject *select = gPad->GetSelected();
1831 if(!select->InheritsFrom("TH2")) { return; }
1834 // Char_t namehist[50];
1836 Char_t rowhistsum[60];
1837 Char_t rowhistmax[60];
1838 Char_t rowhistxmax[60];
1840 sprintf(rowhist, "hrowtime");
1841 sprintf(rowhistxmax ,"hxmax");
1842 sprintf(rowhistmax , "hrowmax");
1845 Int_t px = gPad->GetEventX();
1846 Int_t py = gPad->GetEventY();
1847 Float_t upy = gPad->AbsPixeltoY(py);
1848 Float_t upx = gPad->AbsPixeltoX(px);
1849 Float_t y = gPad->PadtoY(upy);
1850 Float_t x = gPad->PadtoX(upx);
1852 TCanvas*crowtime = 0;
1853 TCanvas*crowmax = 0;
1856 TH2S* fHistIndex = 0;
1858 // ranges from already existing histos
1859 Int_t rowtimexmin = 0;
1860 Int_t rowtimexmax = 0;
1861 Int_t rowtimeymin = 0;
1862 Int_t rowtimeymax = 0;
1863 Float_t rowtimezmin = 0;
1864 Float_t rowtimezmax = 0;
1866 Int_t profrowxmin = 0;
1867 Int_t profrowxmax = 0;
1868 Double_t profrowymin = 0;
1869 Double_t profrowymax = 0;
1871 Int_t profxxmin = 0;
1872 Int_t profxxmax = 0;
1873 Double_t profxymin = 0;
1874 Double_t profxymax = 0;
1880 if( strcmp(select->GetName(),"fHistIROC")==0 || strcmp(select->GetName(),"fHistIROCRMS")==0 ) { fHistIndex = fHistIROCIndex; rocid =1; }
1881 else if(strcmp(select->GetName(),"fHistOROC")==0 || strcmp(select->GetName(),"fHistOROCRMS")==0 ) { fHistIndex = fHistOROCIndex; rocid =2; }
1882 else { cout << " not implemented for this histo " << endl; return; }
1884 gPad->GetCanvas()->FeedbackMode(kTRUE);
1888 // check if canvases exist //
1889 crowtime = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("crowtime");
1890 crowmax = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("crowmax");
1891 cxmax = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("cxmax");
1893 if(!crowtime) crowtime = CreateCanvas("crowtime") ;
1894 if(!crowmax) crowmax = CreateCanvas("crowmax") ;
1895 if(!cxmax ) cxmax = CreateCanvas("cxmax") ;
1897 // check ranges of already existing histos
1898 if(gROOT->Get(rowhist))
1900 rowtimexmin = ((TH2F*)gROOT->Get(rowhist))->GetXaxis()->GetFirst();
1901 rowtimexmax = ((TH2F*)gROOT->Get(rowhist))->GetXaxis()->GetLast();
1902 rowtimeymin = ((TH2F*)gROOT->Get(rowhist))->GetYaxis()->GetFirst();
1903 rowtimeymax = ((TH2F*)gROOT->Get(rowhist))->GetYaxis()->GetLast();
1904 rowtimezmin = ((TH2F*)gROOT->Get(rowhist))->GetMinimum();
1905 rowtimezmax = ((TH2F*)gROOT->Get(rowhist))->GetMaximum();
1907 profrowxmin = ((TH1F*)gROOT->Get(rowhistmax))->GetXaxis()->GetFirst();
1908 profrowxmax = ((TH1F*)gROOT->Get(rowhistmax))->GetXaxis()->GetLast();
1909 profrowymin = ((TH1F*)gROOT->Get(rowhistmax))->GetMinimum();
1910 profrowymax = ((TH1F*)gROOT->Get(rowhistmax))->GetMaximum();
1912 profxxmin = ((TH1F*)gROOT->Get(rowhistxmax))->GetXaxis()->GetFirst();
1913 profxxmax = ((TH1F*)gROOT->Get(rowhistxmax))->GetXaxis()->GetLast();
1914 profxymin = ((TH1F*)gROOT->Get(rowhistxmax))->GetMinimum();
1915 profxymax = ((TH1F*)gROOT->Get(rowhistxmax))->GetMaximum();
1919 delete gROOT->Get(rowhist);
1920 delete gROOT->Get(rowhistmax);
1921 delete gROOT->Get(rowhistsum);
1922 delete gROOT->Get("hxmax");
1923 delete gROOT->Get("legrow");
1926 // get channel for xy bin -> getRow -> getNrows -> getHw for each Pad in Row -> get channel for each hw -> make proj
1927 Int_t testy = fHistIndex->GetYaxis()->FindBin(y);
1928 Int_t testx = fHistIndex->GetXaxis()->FindBin(x);
1929 Int_t binchannel = (Int_t)fHistIndex->GetCellContent(testx,testy);
1931 if(binchannel>30000) return;
1932 if(binchannel<=0 ) { crowtime->Update() ; crowmax->Update() ; return ; }
1935 Int_t hwadd = (Int_t)fHistChannelTime->GetCellContent(binchannel,0);
1936 Int_t row = fMapHand->GetPadRow(hwadd);
1937 Int_t pad = fMapHand->GetPad(hwadd) ;
1938 Int_t numofpads = fMapHand->GetNumofPads(row);
1941 TH2F *hrowtime = new TH2F(rowhist , "" ,numofpads,0,numofpads,GetTimeBins(),0.0,GetTimeBins());
1942 TH1F *hrowmax = new TH1F(rowhistmax , "" ,numofpads,0,numofpads);
1943 TH1F *hxmax = new TH1F(rowhistxmax, "" ,159,0,159 );
1945 // Row profile ///////////
1946 if(fVerb) cout << " Number of pads " << numofpads << endl;
1947 for(Int_t padnr = 0; padnr<numofpads;padnr++)
1949 Int_t addrinrow = fMapHand->GetPadAddInRow(row,padnr );
1950 Int_t channel = (Int_t)fHistAddrMapIndex->GetBinContent(addrinrow);
1951 if(channel==-1) continue;
1953 hrowmax->SetBinContent(padnr+1,fHistAddrMaxAdc->GetBinContent(addrinrow));
1954 TH1D *hp = fHistChannelTime->ProjectionY("hp",channel,channel);
1955 for(Int_t time = 0;time<GetTimeBins();time++) {
1957 Float_t val = hp->GetBinContent(time);
1958 hrowtime->SetCellContent(padnr+1,time+1,val);
1962 // X profile /////////////
1963 Double_t xval = 0.0;
1964 Double_t yval = 0.0;
1965 GetXY(xval,yval,numofpads,row,pad);
1969 for(Int_t nrow = 0; nrow<159; nrow++)
1971 padnr = GetPadAtX(xval,nrow);
1974 hw = fMapHand->GetPadAddInRow(nrow,padnr);
1975 if(fPadMapHw[hw]==-1){ continue ; }
1976 else { hxmax->SetBinContent(nrow+1,fHistAddrMaxAdc->GetBinContent(hw)) ; }
1981 Char_t hxtitle[50] ; sprintf(hxtitle,"max adc in pads at x=%5.1f mm",xval);
1982 hxmax->SetTitle(hxtitle);
1983 hxmax->SetXTitle("row");
1984 if(!GetPedestals()) hxmax->SetYTitle("max adc (baseline sub.)");
1985 else hxmax->SetYTitle("max adc ");
1986 hxmax->SetMinimum(0.01);
1991 hxmax->GetXaxis()->SetRange(profxxmin,profxxmax);
1992 hxmax->SetMinimum(profxymin);
1993 hxmax->SetMaximum(profxymax);
2000 Char_t titlemax[256];
2001 if(rocid==1) {sprintf(title,"%s Row=%d",((TH2*)select)->GetTitle(),row) ; sprintf(titlemax,"IROC max/sum Row=%d",row );}
2002 else {sprintf(title,"%s Row=%d",((TH2*)select)->GetTitle(),row-63); sprintf(titlemax,"OROC max/sum Row=%d",row-63);}
2003 if(fVerb) cout << " set name " << endl;
2008 hrowtime->SetTitleSize(0.04);
2009 hrowtime->SetTitle(title);
2010 hrowtime->SetYTitle("timbin");
2011 hrowtime->SetXTitle("pad in row");
2012 hrowtime->SetZTitle("signal (ADC)");
2014 hrowtime->GetXaxis()->SetTitleColor(1);
2015 hrowtime->SetMaximum(1000.0);
2016 hrowtime->SetMinimum(0.0);
2020 hrowtime->GetXaxis()->SetRange(rowtimexmin,rowtimexmax);
2021 hrowtime->GetYaxis()->SetRange(rowtimeymin,rowtimeymax);
2022 hrowtime->SetMinimum(rowtimezmin);
2023 hrowtime->SetMaximum(rowtimezmax);
2026 hrowtime->Draw("COLZ");
2027 crowtime->UseCurrentStyle();
2030 // max and sum /////////////////////////
2033 hrowmax->GetXaxis()->SetRange(profrowxmin,profrowxmax);
2034 hrowmax->SetMinimum(profrowymin);
2035 hrowmax->SetMaximum(profrowymax);
2037 hrowmax->SetTitleSize(0.04);
2038 hrowmax->SetTitle(title);
2039 hrowmax->SetYTitle("max adc");
2040 hrowmax->SetXTitle("pad in row");
2041 hrowmax->GetXaxis()->SetTitleColor(1);
2043 hrowmax->SetLineColor(2);
2050 //__________________________________________________________________
2051 void AliTPCMonitor::Write10bitChannel()
2054 // Write 10 bit words form histogram for active(last pointed) channel
2056 if(fPadUsedHwAddr==-1){ AliWarning(" No active pad "); return ;}
2058 Int_t pad = (Int_t)fMapHand->GetPad( fPadUsedHwAddr);
2059 Int_t row = (Int_t)fMapHand->GetPadRow(fPadUsedHwAddr);
2060 Int_t channel = (Int_t)fPadMapHw[fPadUsedHwAddr];
2062 Char_t filenameroot[256];
2063 Char_t filenamedat[256];
2064 Char_t projhist[256];
2066 if(fPadUsedRoc==1) { sprintf(projhist,"ProjectionOROC"); }
2067 if(fPadUsedRoc==0) { sprintf(projhist,"ProjectionIROC"); }
2069 sprintf(filenamedat, "Channel_Run%05i_EventID_%i_Pad_%i_Row_%i.dat" ,fRunId,fEventNumber,pad,row);
2070 sprintf(filenameroot,"Channel_Run%05i_EventID_%i_Pad_%i_Row_%i.root" ,fRunId,fEventNumber,pad,row);
2073 if((hpr=(TH1D*)gROOT->Get(projhist)))
2076 TFile f(filenameroot,"recreate");
2081 ofstream datout(filenamedat,ios::out);
2082 datout <<"Timebin \t ADC value " << endl;
2083 for(Int_t i = 1; i <GetTimeBins(); i++)
2085 datout << i << " \t \t " << fPad[channel][i] << endl;
2091 AliWarning("No projection histo found ");
2095 //__________________________________________________________________
2096 void AliTPCMonitor::ExecTransform()
2099 // Make Fast Fourier Transformation for active pad
2100 // fft is only performed for a data sample of size 2^n
2101 // reduce window according to largest power of 2 which is smaller than the viewing range
2103 Char_t namecanv[256];
2104 Char_t namecanv2[256];
2105 Char_t projhist[256];
2106 Char_t namehtrimag[256];
2107 Char_t namehtrreal[256];
2108 Char_t namehtrmag[256];
2110 if(fPadUsedRoc==1) { sprintf(namecanv,"coroc_ch_trans") ; sprintf(namecanv2,"coroc_ch_trans2") ; sprintf(projhist,"ProjectionOROC"); }
2111 if(fPadUsedRoc==0) { sprintf(namecanv,"ciroc_ch_trans") ; sprintf(namecanv2,"ciroc_ch_trans2") ; sprintf(projhist,"ProjectionIROC"); }
2115 if((TH1D*)gROOT->Get(projhist)==0){AliWarning("Proj histo does not exist \n Move mouse over 2d histo choose channel \n and drag mouse form histo again!"); return ;}
2116 else hproj = (TH1D*)gROOT->Get(projhist) ;
2119 if(fPadUsedRoc==1) { sprintf(namehtrimag,"htransimagfreq_oroc"); sprintf(namehtrreal,"htransrealfreq_oroc"); sprintf(namehtrmag,"htransmagfreq_oroc"); }
2120 else { sprintf(namehtrimag,"htransimagfreq_iroc"); sprintf(namehtrreal,"htransrealfreq_iroc"); sprintf(namehtrmag,"htransmagfreq_iroc"); }
2122 if( gROOT->Get(namehtrimag)) delete gROOT->Get(namehtrimag);
2123 if( gROOT->Get(namehtrreal)) delete gROOT->Get(namehtrreal);
2124 if( gROOT->Get(namehtrmag)) delete gROOT->Get(namehtrmag);
2126 TCanvas *ctrans = 0;
2127 if(!(ctrans = (TCanvas*)gROOT->GetListOfCanvases()->FindObject(namecanv)))
2129 ctrans = CreateCanvas(namecanv);
2130 ctrans->Divide(1,2);
2132 TCanvas *ctrans2 = 0;
2133 if(!(ctrans2 = (TCanvas*)gROOT->GetListOfCanvases()->FindObject(namecanv2)))
2135 ctrans2 = CreateCanvas(namecanv2);
2136 // ctrans2->Divide(1,2);
2139 Int_t binfirst = hproj->GetXaxis()->GetFirst();
2140 Int_t binlast = hproj->GetXaxis()->GetLast();
2141 Int_t bins = binlast -binfirst +1;
2144 for(Int_t pot = 0; pot<=10 ; pot++)
2146 Int_t comp = (Int_t)TMath::Power(2,pot);
2147 if(bins>=comp)power = pot;
2150 bins = (Int_t)TMath::Power(2,power);
2152 // sampling frequency ;
2153 Double_t deltat = 1.0/(Float_t)GetSamplingFrequency();
2156 TH1D* htransrealfreq = new TH1D(namehtrreal,namehtrreal,10000,-1/(2*deltat),1/(2*deltat));
2157 TH1D* htransimagfreq = new TH1D(namehtrimag,namehtrimag,10000,-1/(2*deltat),1/(2*deltat));
2158 TH1D* htransmag = new TH1D(namehtrmag,namehtrmag,10000,-1/(2*deltat),1/(2*deltat));
2160 Char_t titlereal[256];
2161 Char_t titleimag[256];
2162 Char_t titlemag[256];
2163 if(fPadUsedRoc==1) { sprintf(titlereal,"OROC DFT real part"); sprintf(titleimag,"OROC DFT imag part"); sprintf(titlemag,"OROC DFT magnitude"); }
2164 else { sprintf(titlereal,"IROC DFT real part"); sprintf(titleimag,"IROC DFT imag part"); sprintf(titlemag,"IROC DFT magnitude"); }
2166 htransrealfreq->SetTitle(titlereal); htransrealfreq->SetXTitle("f/hz"); htransrealfreq->SetYTitle("z_{real}(f)");
2167 htransimagfreq->SetTitle(titleimag); htransimagfreq->SetXTitle("f/hz"); htransimagfreq->SetYTitle("z_{imag}(f)");
2168 htransmag->SetTitle(titlemag); htransmag->SetXTitle("f/hz"); htransmag->SetYTitle("mag(f)");
2170 // create complex packed data array
2171 const Int_t kdatasiz = 2*bins;
2172 Double_t* data = new Double_t[kdatasiz];
2173 for(Int_t i=0;i<2*bins;i++) { data[i] = 0.0;}
2174 for(Int_t i=0;i<bins;i++) { data[2*i] = (Double_t)hproj->GetBinContent(binfirst+i); }
2176 // make fourier transformation
2177 AliTPCMonitorFFT* four = new AliTPCMonitorFFT();
2178 four->ComplexRadix2ForwardWrap(data,1,bins);
2180 // write output and fill histos forward
2181 Double_t freq = 0.0;
2182 for(Int_t i=0;i<2*bins;i++)
2186 if(i<(bins/2)) { freq = i/(bins*deltat) ; }
2187 else { freq = -1*((bins-i)/(bins*deltat)); }
2188 htransrealfreq->Fill( freq,data[2*i] );
2189 htransimagfreq->Fill( freq,data[2*i+1]);
2190 htransmag->Fill( freq, TMath::Sqrt(data[2*i]*data[2*i]+data[2*i+1]*data[2*i+1]) );
2195 htransrealfreq->Draw();
2197 htransimagfreq->Draw();
2206 //__________________________________________________________________
2207 void AliTPCMonitor::ShowSel(Int_t* compval)
2210 // Show only selected components
2211 // First restore original histogram from clone
2212 // Than remove all not matching pads form histos
2214 Int_t connector = 0;
2216 Int_t altrochip = 0;
2217 Int_t feclocbran = 0;
2224 Float_t maxiroc = fHistIROCClone->GetMaximum();
2225 Float_t maxoroc = fHistOROCClone->GetMaximum();
2228 // restore original histos
2229 for(Int_t row = 0; row<fkNRowsIroc; row++)
2231 for(Int_t pad = 0; pad<fkNPadsIroc; pad++)
2233 index = (Int_t)fHistIROCIndex->GetCellContent(row+1,pad+1);
2234 if(index==-1)continue;
2235 else fHistIROC->SetCellContent(row+1,pad+1,fHistIROCClone->GetCellContent(row+1,pad+1));
2238 for(Int_t row = 0; row<fkNRowsOroc; row++)
2240 for(Int_t pad = 0; pad<fkNPadsOroc; pad++)
2242 index = (Int_t)fHistOROCIndex->GetCellContent(row+1,pad+1);
2243 if(index==-1)continue;
2244 else fHistOROC->SetCellContent(row+1,pad+1,fHistOROCClone->GetCellContent(row+1,pad+1));
2249 // remove not matching entries from fHistIROC/fHistOROC
2252 TH2S* fHistIndex =0;
2256 for(Int_t row = 0; row< (fkNRowsIroc + fkNRowsOroc); row++)
2258 if(row<fkNRowsIroc) { fHist=fHistIROC ; fHistIndex = fHistIROCIndex; npads = fkNPadsIroc; subrows =0 ;}
2259 else { fHist=fHistOROC ; fHistIndex = fHistOROCIndex; npads = fkNPadsOroc; subrows =fkNRowsIroc;}
2261 for(Int_t pad = 0; pad<npads; pad++)
2263 index = (Int_t)fHistIndex->GetCellContent(row -subrows +1,pad+1);
2264 if(index==-1) continue ;
2265 hwadd = (Int_t)fHistChannelTime->GetCellContent(index,0);
2268 fecnr = fMapHand->GetFECfromHw(hwadd);
2269 if(compval[0]!=-1 && fecnr!=compval[0]) { fHist->SetCellContent(row-subrows+1,pad+1,0); continue; }
2272 rcuget = (hwadd & AliTPCMonitorAltro::GetHwMaskRCU())>> 12;
2273 if(compval[1]!=-1 && rcuget!=compval[1]) { fHist->SetCellContent(row-subrows+1,pad+1,0); continue; }
2276 branch = fMapHand->U2fGetBranch(fecnr) ;
2277 if(compval[2]!=-1 && branch!=compval[2]) { fHist->SetCellContent(row-subrows+1,pad+1,0); continue; }
2280 feclocbran= fMapHand->U2fGetFECinBranch(fecnr) ;
2281 if(compval[3]!=-1 && feclocbran!=compval[3]) { fHist->SetCellContent(row-subrows+1,pad+1,0); continue; }
2284 connector = fMapHand->GetFECconnector(hwadd);
2285 if(compval[4]!=-1 && connector!=compval[4]) { fHist->SetCellContent(row-subrows+1,pad+1,0); continue; }
2288 altrochip = fMapHand->GetAltro(hwadd);
2289 if(compval[5]!=-1 && altrochip!=compval[5]) { fHist->SetCellContent(row-subrows+1,pad+1,0); continue; }
2296 if(gROOT->GetListOfCanvases()->FindObject("ciroc"))
2298 c1 = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("ciroc");
2300 fHistIROC->Draw("COLZ");
2301 fHistIROC->SetMaximum(maxiroc);
2302 fHistIROC->SetMinimum(0.0);
2305 if(gROOT->GetListOfCanvases()->FindObject("coroc"))
2307 c2 = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("coroc");
2309 fHistOROC->Draw("COLZ");
2310 fHistOROC->SetMaximum(maxoroc);
2311 fHistOROC->SetMinimum(0.0);
2317 //__________________________________________________________________
2318 void AliTPCMonitor::ResizeCanv()
2320 // Resize canvases and delete some of them
2323 sprintf(carry1,".x %s/TPC/AliTPCMonitorExec.C(1)",gSystem->Getenv("ALICE_ROOT"));
2325 sprintf(carry3,".x %s/TPC/AliTPCMonitorExec.C(2)",gSystem->Getenv("ALICE_ROOT"));
2326 if(fVerb) cout << " canv 1 " << endl;
2328 if(gROOT->GetListOfCanvases()->FindObject( "coroc_ch")) { delete gROOT->GetListOfCanvases()->FindObject("coroc_ch") ; }
2329 if(gROOT->GetListOfCanvases()->FindObject( "ciroc_ch")) { delete gROOT->GetListOfCanvases()->FindObject("ciroc_ch") ; }
2331 // for 2dim plots delete create and draw again
2332 if(gROOT->GetListOfCanvases()->FindObject("ciroc"))
2334 delete gROOT->GetListOfCanvases()->FindObject("ciroc");
2335 TCanvas* ciroc = CreateCanvas("ciroc");
2337 fHistIROC->Draw("COLZ");
2338 ciroc->AddExec("pad",carry1);
2339 ciroc->AddExec("row",carry3);
2343 // for 2dim plots delete create and draw again
2344 if(gROOT->GetListOfCanvases()->FindObject("coroc"))
2346 delete gROOT->GetListOfCanvases()->FindObject("coroc");
2347 TCanvas* coroc = CreateCanvas("coroc");
2349 fHistOROC->Draw("COLZ");
2351 coroc->AddExec("pad",carry1);
2352 coroc->AddExec("row",carry3);
2357 if(gROOT->GetListOfCanvases()->FindObject( "cbasemean")) { delete gROOT->GetListOfCanvases()->FindObject("cbasemean"); }
2358 if(gROOT->GetListOfCanvases()->FindObject( "cbase")) { delete gROOT->GetListOfCanvases()->FindObject("cbase");}
2359 if(gROOT->GetListOfCanvases()->FindObject( "cbaserms")) { delete gROOT->GetListOfCanvases()->FindObject("cbaserms"); }
2360 if(gROOT->GetListOfCanvases()->FindObject( "cmax")) { delete gROOT->GetListOfCanvases()->FindObject("cmax"); }
2361 if(gROOT->GetListOfCanvases()->FindObject( "csum")) { delete gROOT->GetListOfCanvases()->FindObject("csum"); }
2362 if(gROOT->GetListOfCanvases()->FindObject( "ciroc_ch_trans")) { delete gROOT->GetListOfCanvases()->FindObject("ciroc_ch_trans");}
2363 if(gROOT->GetListOfCanvases()->FindObject( "coroc_ch_trans")) { delete gROOT->GetListOfCanvases()->FindObject("coroc_ch_trans");}
2364 if(gROOT->GetListOfCanvases()->FindObject( "crowtime")) { delete gROOT->GetListOfCanvases()->FindObject("crowtime"); }
2365 if(gROOT->GetListOfCanvases()->FindObject( "crowmax")) { delete gROOT->GetListOfCanvases()->FindObject("crowmax"); }
2366 if(gROOT->GetListOfCanvases()->FindObject( "cxmax")) { delete gROOT->GetListOfCanvases()->FindObject("cxmax"); }
2367 if(gROOT->GetListOfCanvases()->FindObject( "crmsoroc")) { delete gROOT->GetListOfCanvases()->FindObject("crmsoroc"); fExecPadOrocRms = 0; }
2368 if(gROOT->GetListOfCanvases()->FindObject( "crmsiroc")) { delete gROOT->GetListOfCanvases()->FindObject("crmsiroc"); fExecPadIrocRms = 0; }
2369 if(gROOT->GetListOfCanvases()->FindObject( "crowmax")) { delete gROOT->GetListOfCanvases()->FindObject("crowmax"); }
2370 if(gROOT->GetListOfCanvases()->FindObject( "crowmax")) { delete gROOT->GetListOfCanvases()->FindObject("crowmax"); }
2377 //__________________________________________________________________
2378 Int_t AliTPCMonitor::ExecProcess()
2380 // Executable for global Histogram
2381 // Will be called from /TPC/AliTPCMonitorExec.C(3)
2382 // Call ProcessEvent for same event and sector pointed at
2387 Int_t event = gPad->GetEvent();
2388 if(event != 61) return -1;
2390 TObject *select = gPad->GetSelected();
2391 if(!select) return -1;
2392 if(!select->InheritsFrom("TH2")) {gPad->SetUniqueID(0); return -1; }
2393 if( strcmp(select->GetName(),"hglobal" )==0 || ( strcmp(select->GetName(),"SIDE A" )==0) ) side = 0;
2394 else if( strcmp(select->GetName(),"hglobal2")==0 || ( strcmp(select->GetName(),"SIDE C" )==0) ) side = 1;
2397 Int_t px = gPad->GetEventX();
2398 Int_t py = gPad->GetEventY();
2399 Float_t upy = gPad->AbsPixeltoY(py);
2400 Float_t upx = gPad->AbsPixeltoX(px);
2401 Float_t y = gPad->PadtoY(upy);
2402 Float_t x = gPad->PadtoX(upx);
2404 Int_t testy = ((TH2*)select)->GetYaxis()->FindBin(y);
2405 Int_t testx = ((TH2*)select)->GetXaxis()->FindBin(x);
2406 if(((TH2*)select)->GetCellContent(testx,testy)==0) return -1 ;
2408 Float_t alpha = 0.0;
2409 if(x>0.0 && y > 0.0) alpha = TMath::Abs(TMath::ATan(TMath::Abs(x/y)));
2410 if(x>0.0 && y < 0.0) alpha = TMath::Abs(TMath::ATan(TMath::Abs(y/x)));
2411 if(x<0.0 && y < 0.0) alpha = TMath::Abs(TMath::ATan(TMath::Abs(x/y)));
2412 if(x<0.0 && y > 0.0) alpha = TMath::Abs(TMath::ATan(TMath::Abs(y/x)));
2414 if(x>0.0 && y < 0.0) alpha += ( TMath::Pi()/2);
2415 if(x<0.0 && y < 0.0) alpha += ( TMath::Pi());
2416 if(x<0.0 && y > 0.0) alpha += (1.5*TMath::Pi());
2418 sector = (Int_t)(alpha/(2*TMath::Pi()/18.0));
2419 if(alpha> (sector+0.5)*(2*TMath::Pi()/18.0)) sector+=1;
2421 if(sector==18 && side ==0 ) {
2422 AliWarning("There was a wromg assignment of sector 0 with sector 18. Check sectors");
2426 sector = (18-sector +4)%18;
2427 SetLastSector(sector+ side*18);
2428 SetProcNextEvent(0);
2430 if(fVerb) cout << "AliTPCMonitor::ExecProcess() next side " << side << " next sector " << sector << endl;
2432 return (Int_t)ProcessEvent();
2436 //__________________________________________________________________
2437 Int_t AliTPCMonitor::GetRCUPatch(Int_t runid, Int_t eqid) const
2440 // Return RCU patch index for given equipment id eqid
2443 if ( eqid<768 || eqid>983 ) return 0; //no TPC eqid
2446 if(eqid>=1000) return 0;
2447 patch = fMapEqidsRcu[eqid] ;
2451 if(eqid==408) {patch = 13*6+4 +0; }
2452 if(eqid==409) {patch = 13*6+5 +0; }
2453 if(eqid==509) {patch = 13*6+0 +0; }
2454 if(eqid==512) {patch = 13*6+3 +0; }
2455 if(eqid==513) {patch = 13*6+1 +0; }
2456 if(eqid==517) {patch = 13*6+2 +0; }
2458 if(eqid==404) {patch = 4*6+5 +0; }
2459 if(eqid==504) {patch = 4*6+4 +0; }
2460 if(eqid==407) {patch = 4*6+3 +0; }
2461 if(eqid==503) {patch = 4*6+2 +0; }
2462 if(eqid==508) {patch = 4*6+1 +0; }
2463 if(eqid==506) {patch = 4*6+0 +0; }
2468 //__________________________________________________________________
2469 void AliTPCMonitor::DumpHeader(AliRawReaderRoot * readerROOT) const
2471 // Dump Event header for ROOT format
2473 cout << "EventHeader : fReaderROOT->GetEquipmentSize() :" << readerROOT->GetEquipmentSize() << endl;
2474 cout << "EventHeader : fReaderROOT->GetType() :" << readerROOT->GetType() << endl;
2475 cout << "EventHeader : fReaderROOT->GetRunNumber() :" << readerROOT->GetRunNumber() << endl;
2476 cout << "EventHeader : fReaderROOT->GetEventId() :" << *(readerROOT->GetEventId()) << endl;
2477 cout << "EventHeader : fReaderROOT->GetLDCId() :" << readerROOT->GetLDCId() << endl;
2478 cout << "EventHeader : fReaderROOT->GetGDCId() :" << readerROOT->GetGDCId() << endl;
2481 //__________________________________________________________________
2482 void AliTPCMonitor::DumpHeader(AliTPCMonitorDateFormat* dateform) const
2484 // Dump Event header for DATE format
2486 cout << "EquipmentHeader : dateform->GetEquipmentSize() :" << dateform->GetEquipmentSize() << endl;
2487 cout << "EquipmentHeader : dateform->GetEquipmentType() :" << dateform->GetEquipmentType() << endl;
2488 cout << "EquipmentHeader : dateform->GetEquipmentID() :" << dateform->GetEquipmentID() << endl;
2489 cout << "EquipmentHeader : dateform->GetEquipmentTypeAttribute() :" << dateform->GetEquipmentTypeAttribute() << endl;
2490 cout << "EquipmentHeader : dateform->GetEquipmentBasicSize() :" << dateform->GetEquipmentBasicSize() << endl;
2491 cout << "EquipmentHeader : dateform->GetEquipmentHeaderSize() :" << dateform->GetEquipmentHeaderSize() << endl;
2492 cout << "EquipmentHeader : dateform->IsLastSubEventHeader() :" << dateform->IsLastSubEventHeader() << endl;
2495 //__________________________________________________________________
2496 Double_t AliTPCMonitor::Gamma4(Double_t* x, Double_t* par) {
2498 // Gamma4 function used to fit signals
2499 // Defined in sections: diverging branch set to 0
2503 val = par[0]*exp(4.0)* pow((x[0]-par[1])/par[2],4)*exp(-4.0*(x[0]-par[1])/par[2])+ par[3];
2509 //__________________________________________________________________
2510 TCanvas* AliTPCMonitor::CreateCanvas(const Char_t* name)
2516 Int_t xoffset = GetCanvasXOffset();
2517 Int_t xsize = GetCanvasXSize();
2518 Int_t ysize = GetCanvasYSize();
2519 Int_t xspace = GetCanvasXSpace();
2520 Int_t yspace = GetCanvasYSpace();
2522 // ROC 2dim max distribution
2523 if( strcmp(name,"coroc" )==0) { canv = new TCanvas("coroc" ,"coroc" , -1+xoffset,(Int_t)(yspace+0.5*ysize) ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2524 else if(strcmp(name,"ciroc" )==0) { canv = new TCanvas("ciroc" ,"ciroc" , -1+xoffset, 0 ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2525 // ROC 2dim rms distribution
2526 else if(strcmp(name,"crmsoroc" )==0) { canv = new TCanvas("crmsoroc" ,"crmsoroc" , -1+xoffset,(Int_t)(yspace+0.5*ysize) ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2527 else if(strcmp(name,"crmsiroc" )==0) { canv = new TCanvas("crmsiroc" ,"crmsiroc" , -1+xoffset, 0 ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2528 // Global ADC max Histos
2529 else if(strcmp(name,"SIDE C all" )==0) { canv = new TCanvas("SIDE C all" ,"SIDE C all" , (Int_t)(3*xspace+ xoffset),(Int_t)(yspace+0.5*ysize) ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2530 else if(strcmp(name,"SIDE A all" )==0) { canv = new TCanvas("SIDE A all" ,"SIDE A all" , (Int_t)(3*xspace+ xoffset), 0 ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2531 // 1 dim max sum basekine distribution
2532 else if(strcmp(name,"cmax" )==0) { canv = new TCanvas("cmax" ,"cmax" , -1+xoffset, 3*yspace ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv; }
2533 else if(strcmp(name,"csum" )==0) { canv = new TCanvas("csum" ,"csum" , xspace+xoffset, 3*yspace ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv; }
2534 else if(strcmp(name,"cbasemean" )==0) { canv = new TCanvas("cbasemean" ,"cbasemean" , 2*xspace+xoffset, 3*yspace ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv; }
2535 else if(strcmp(name,"cbaserms" )==0) { canv = new TCanvas("cbaserms" ,"cbaserms" , 3*xspace+xoffset, 3*yspace ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv; }
2536 // Projections of single channel
2537 else if(strcmp(name,"coroc_ch" )==0) { canv = new TCanvas("coroc_ch" ,"coroc_ch" , (Int_t)(1.5*xspace+xoffset),(Int_t)(yspace+0.5*ysize),(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2538 else if(strcmp(name,"ciroc_ch" )==0) { canv = new TCanvas("ciroc_ch" ,"ciroc_ch" , (Int_t)(1.5*xspace+xoffset), 0 ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2539 // FFT for single channel
2540 else if(strcmp(name,"coroc_ch_trans")==0) { canv = new TCanvas("coroc_ch_trans","coroc_ch_trans",(Int_t)(3.0*xspace+xoffset),(Int_t)(yspace+0.5*ysize),(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2541 else if(strcmp(name,"ciroc_ch_trans")==0) { canv = new TCanvas("ciroc_ch_trans","ciroc_ch_trans",(Int_t)(3.0*xspace+xoffset), 0 ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2542 else if(strcmp(name,"coroc_ch_trans2")==0) { canv = new TCanvas("coroc_ch_trans2","coroc_ch_trans2",(Int_t)(3.0*xspace+xoffset),(Int_t)(yspace+0.5*ysize),(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2543 else if(strcmp(name,"ciroc_ch_trans2")==0) { canv = new TCanvas("ciroc_ch_trans2","ciroc_ch_trans2",(Int_t)(3.0*xspace+xoffset), 0 ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2544 // row profile histograms
2545 else if(strcmp(name,"crowtime" )==0) { canv = new TCanvas("crowtime" ,"crowtime" , 1*xspace+xoffset, 2*yspace +ysize ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv; }
2546 else if(strcmp(name,"crowmax" )==0) { canv = new TCanvas("crowmax" ,"crowmax" , 2*xspace+xoffset, 2*yspace +ysize ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv; }
2547 else if(strcmp(name,"cxmax" )==0) { canv = new TCanvas("cxmax" ,"cxmax" , 3*xspace+xoffset, 2*yspace +ysize ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv; }
2548 else { cout << " Warning Canvas name unknown " << endl; return 0 ; }
2551 //__________________________________________________________________
2552 void AliTPCMonitor::WriteHistos()
2554 // Writes all available histograms to a file in current directory
2555 // File name will be specified by : sector, side, runid and eventnumber
2557 if(GetEventProcessed())
2559 AliInfo("Write histos to file");
2561 sprintf(name,"SIDE_%i_SECTOR_%02i_RUN_%05i_EventID_%06i.root",(GetLastSector()/18),(GetLastSector()%18),fRunId,fEventNumber);
2562 TFile* f = new TFile(name,"recreate");
2563 for(Int_t i =0; i<fHistList->GetEntries(); i++)
2565 if(((TH1*)fHistList->At(i))!=0)
2567 ((TH1*)fHistList->At(i))->Write();
2575 AliError("No Event Processed : Chose Format , File and push 'Next Event' ");
2580 //__________________________________________________________________
2581 TH1* AliTPCMonitor::GetHisto(char* histname)
2584 // Returns histogram specified by histname
2585 // check available names for histos in CreateHistos()
2588 if((TH1*)fHistList->FindObject(histname))
2590 hist = (TH1*)fHistList->FindObject(histname);
2594 cout << " AliTPCMonitor::GetHisto :: Can not find histo with name " << histname << endl;