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 "AliTPCMonitorFFT.h"
56 #include "AliRawReader.h"
57 #include "AliRawReaderRoot.h"
58 #include "AliRawEventHeaderBase.h"
59 #include "AliAltroRawStreamV3.h"
67 #include "TDirectory.h"
69 #include "TPaveText.h"
71 #include <Riostream.h>
73 ClassImp(AliTPCMonitor)
75 const Int_t AliTPCMonitor::fgkHwMaskFEC = 0x0780;
76 const Int_t AliTPCMonitor::fgkHwMaskBranch = 0x0800;
77 const Int_t AliTPCMonitor::fgkHwMaskFECChannel = 0x007f;
78 const Int_t AliTPCMonitor::fgkHwMaskAltroChannel = 0x000f;
79 const Int_t AliTPCMonitor::fgkHwMaskAltroChip = 0x0070;
80 const Int_t AliTPCMonitor::fgkHwMaskRCU = 0x7000;
82 //____________________________________________________________________________
83 AliTPCMonitor::AliTPCMonitor(char* name, char* title) :
84 AliTPCMonitorConfig(name,title),
85 fPad(new Int_t*[GetMaxHwAddr()]),
86 fPadMapHw(new Float_t[GetMaxHwAddr()]),
87 fPadMapRCU(new Int_t*[GetMaxHwAddr()]),
103 fHistAddrMapIndex(0),
105 fHistAddrBaseMean(0),
109 fHistDistrSumIROC(0),
110 fHistDistrMaxIROC(0),
111 fHistDistrSumOROC(0),
112 fHistDistrMaxOROC(0),
113 fHistDistrBase2dIROC(0),
114 fHistDistrBase2dOROC(0),
115 fHistDistrBaseRmsIROC(0),
116 fHistDistrBaseMeanIROC(0),
117 fHistDistrBaseRmsOROC(0),
118 fHistDistrBaseMeanOROC(0),
121 fHistList(new TObjArray()),
148 fMapEqidsSec(new Int_t*[36]),
149 fMapEqidsRcu(new Int_t[1000]),
157 for(Int_t i = 0; i<GetMaxHwAddr(); i++) { fPad[i] = new Int_t[GetTimeBins()];}
158 for(Int_t i = 0; i<GetMaxHwAddr(); i++) { fPadMapRCU[i] = new Int_t[6];}
159 for(Int_t i = 0; i<36; i++) { fMapEqidsSec[i] = new Int_t[6];}
163 if (!gDirectory->GetList())
165 Warning("Build","Current directory is not a valid directory");
168 AliTPCMonitor *hold = (AliTPCMonitor*)gDirectory->GetList()->FindObject(GetName());
171 Warning("Build","Replacing existing histogram: %s (Potential memory leak).",GetName());
172 gDirectory->GetList()->Remove(hold);
174 gDirectory->Append(this);
181 //____________________________________________________________________________
182 AliTPCMonitor::AliTPCMonitor(const AliTPCMonitor &monitor):
183 AliTPCMonitorConfig(monitor.GetName(),monitor.GetTitle()),
184 fPad(new Int_t*[GetMaxHwAddr()]),
185 fPadMapHw(new Float_t[GetMaxHwAddr()]),
186 fPadMapRCU(new Int_t*[GetMaxHwAddr()]),
202 fHistAddrMapIndex(0),
204 fHistAddrBaseMean(0),
208 fHistDistrSumIROC(0),
209 fHistDistrMaxIROC(0),
210 fHistDistrSumOROC(0),
211 fHistDistrMaxOROC(0),
212 fHistDistrBase2dIROC(0),
213 fHistDistrBase2dOROC(0),
214 fHistDistrBaseRmsIROC(0),
215 fHistDistrBaseMeanIROC(0),
216 fHistDistrBaseRmsOROC(0),
217 fHistDistrBaseMeanOROC(0),
220 fHistList(new TObjArray()),
221 fkNRowsIroc(monitor.fkNRowsIroc),
222 fkNRowsOroc(monitor.fkNRowsOroc),
223 fkNPadsIroc(monitor.fkNPadsIroc),
224 fkNPadsOroc(monitor.fkNPadsOroc),
225 fkNPadMinIroc(monitor.fkNPadMinIroc),
226 fkNPadMinOroc(monitor.fkNPadMinOroc),
227 fkNPadMaxIroc(monitor.fkNPadMaxIroc),
228 fkNPadMaxOroc(monitor.fkNPadMaxOroc),
229 fVerb(monitor.fVerb),
230 fLastEv(monitor.fLastEv),
231 fEventNumber(monitor.fEventNumber),
232 fEventNumberOld(monitor.fEventNumberOld),
233 fDisableFit(monitor.fDisableFit),
234 fExecGlob(monitor.fExecGlob),
235 fExecPlaneMax(monitor.fExecPlaneMax),
236 fExecPadIrocRms(monitor.fExecPadIrocRms),
237 fExecPadOrocRms(monitor.fExecPadOrocRms),
238 fRunId(monitor.fRunId),
239 fEqId(monitor.fEqId),
240 fPadUsedRoc(monitor.fPadUsedRoc),
241 fPadUsedHwAddr(monitor.fPadUsedHwAddr),
242 fGdcId(monitor.fGdcId),
243 fLdcId(monitor.fLdcId),
244 fLdcIdOld(monitor.fLdcIdOld),
245 fMapEqidsSec(new Int_t*[36]),
246 fMapEqidsRcu(new Int_t[1000]),
247 fMirror(monitor.fMirror),
248 fChannelIter(monitor.fChannelIter),
249 fMapHand(monitor.fMapHand),
250 fRawReader(monitor.fRawReader)
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 fRawReader=monitor.fRawReader;
364 fHistList = new TObjArray();
365 fHistIROC=(TH2F*)monitor.fHistIROC->Clone(); fHistList->Add(fHistIROC);
366 fHistOROC=(TH2F*)monitor.fHistOROC->Clone(); fHistList->Add(fHistOROC);
367 fHistIROCIndex=(TH2S*)monitor.fHistIROCIndex->Clone(); fHistList->Add(fHistIROCIndex);
368 fHistOROCIndex=(TH2S*)monitor.fHistOROCIndex->Clone(); fHistList->Add(fHistOROCIndex);
369 fHistIROCTime=(TH2F*)monitor.fHistIROCTime->Clone(); fHistList->Add(fHistIROCTime);
370 fHistOROCTime=(TH2F*)monitor.fHistOROCTime->Clone(); fHistList->Add(fHistOROCTime);
371 fHistIROCClone=(TH2F*)monitor.fHistIROCClone->Clone(); fHistList->Add(fHistIROCClone);
372 fHistOROCClone=(TH2F*)monitor.fHistOROCClone->Clone(); fHistList->Add(fHistOROCClone);
373 fHistIROCRMS=(TH2F*)monitor.fHistIROCRMS->Clone(); fHistList->Add(fHistIROCRMS);
374 fHistOROCRMS=(TH2F*)monitor.fHistOROCRMS->Clone(); fHistList->Add(fHistOROCRMS);
375 fHistIROCBASE=(TH2F*)monitor.fHistIROCBASE->Clone(); fHistList->Add(fHistIROCBASE);
376 fHistOROCBASE=(TH2F*)monitor.fHistOROCBASE->Clone(); fHistList->Add(fHistOROCBASE);
377 fHistIROCSUM=(TH2F*)monitor.fHistIROCSUM->Clone(); fHistList->Add(fHistIROCSUM);
378 fHistOROCSUM=(TH2F*)monitor.fHistOROCSUM->Clone(); fHistList->Add(fHistOROCSUM);
380 fHistChannelTime=(TH2F*)monitor.fHistChannelTime->Clone(); fHistList->Add(fHistChannelTime);
382 fHistAddrMapIndex=(TH1F*)monitor.fHistAddrMapIndex->Clone(); fHistList->Add(fHistAddrMapIndex);
383 fHistAddrMaxAdc=(TH1F*)monitor.fHistAddrMaxAdc->Clone(); fHistList->Add(fHistAddrMaxAdc);
384 fHistAddrBaseMean=(TH1F*)monitor.fHistAddrBaseMean->Clone(); fHistList->Add(fHistAddrBaseMean);
385 fHistAddrMaxAdcX=(TH1F*)monitor.fHistAddrMaxAdcX->Clone(); fHistList->Add(fHistAddrMaxAdcX);
386 fHistAddrAdcSum=(TH1F*)monitor.fHistAddrAdcSum->Clone(); fHistList->Add(fHistAddrAdcSum);
387 fHistAddrBaseRms=(TH1F*)monitor.fHistAddrBaseRms->Clone(); fHistList->Add(fHistAddrBaseRms);
390 fHistDistrSumIROC=(TH1F*)monitor.fHistDistrSumIROC->Clone(); fHistList->Add(fHistDistrSumIROC);
391 fHistDistrMaxIROC=(TH1F*)monitor.fHistDistrMaxIROC->Clone(); fHistList->Add(fHistDistrMaxIROC);
392 fHistDistrSumOROC=(TH1F*)monitor.fHistDistrSumOROC->Clone(); fHistList->Add(fHistDistrSumOROC);
393 fHistDistrMaxOROC=(TH1F*)monitor.fHistDistrMaxOROC->Clone(); fHistList->Add(fHistDistrMaxOROC);
395 fHistDistrBase2dIROC=(TH2F*)monitor.fHistDistrBase2dIROC->Clone(); fHistList->Add(fHistDistrBase2dIROC);
396 fHistDistrBase2dOROC=(TH2F*)monitor.fHistDistrBase2dOROC->Clone(); fHistList->Add(fHistDistrBase2dOROC);
397 fHistDistrBaseRmsIROC=(TH1D*)monitor.fHistDistrBaseRmsIROC->Clone(); fHistList->Add(fHistDistrBaseRmsIROC);
398 fHistDistrBaseMeanIROC=(TH1D*)monitor.fHistDistrBaseMeanIROC->Clone(); fHistList->Add(fHistDistrBaseMeanIROC);
399 fHistDistrBaseRmsOROC=(TH1D*)monitor.fHistDistrBaseRmsOROC->Clone(); fHistList->Add(fHistDistrBaseRmsOROC);
400 fHistDistrBaseMeanOROC=(TH1D*)monitor.fHistDistrBaseMeanOROC->Clone(); fHistList->Add(fHistDistrBaseMeanOROC);
402 fHistGlobalMaxA=(TH2S*)monitor.fHistGlobalMaxA->Clone(); fHistList->Add(fHistGlobalMaxA);
403 fHistGlobalMaxC=(TH2S*)monitor.fHistGlobalMaxC->Clone(); fHistList->Add(fHistGlobalMaxC);
405 fPad = new Int_t*[monitor.GetMaxHwAddr()];
406 for(Int_t i = 0; i<GetMaxHwAddr(); i++) { fPad[i] = new Int_t[monitor.GetTimeBins()];}
408 fPadMapRCU = new Int_t*[monitor.GetMaxHwAddr()];
409 for(Int_t i = 0; i<monitor.GetMaxHwAddr(); i++) { fPadMapRCU[i] = new Int_t[6];}
411 fPadMapHw = new Float_t[monitor.GetMaxHwAddr()];
413 fMapEqidsRcu = new Int_t[1000];
414 fMapEqidsSec = new Int_t*[36];
415 for(Int_t i = 0; i<36; i++) { fMapEqidsSec[i] = new Int_t[6];}
420 if (!gDirectory->GetList())
422 Warning("Build","Current directory is not a valid directory");
425 AliTPCMonitor *hold = (AliTPCMonitor*)gDirectory->GetList()->FindObject(monitor.GetName());
428 Warning("Build","Replacing existing histogram: %s (Potential memory leak).",monitor.GetName());
429 gDirectory->GetList()->Remove(hold);
431 gDirectory->Append(this);
438 //____________________________________________________________________________
439 AliTPCMonitor::~AliTPCMonitor()
443 for(Int_t i = 0; i<GetMaxHwAddr(); i++) { delete[] fPad[i] ;}
444 for(Int_t i = 0; i<GetMaxHwAddr(); i++) { delete[] fPadMapRCU[i];}
449 //____________________________________________________________________________
450 void AliTPCMonitor::CreateHistos()
452 // Create histograms to be displayed
454 if(fVerb) cout << " create new ones " << endl;
455 fHistIROC = new TH2F("fHistIROC" ,"fHistIROC" ,fkNRowsIroc,0,fkNRowsIroc,fkNPadsIroc, fkNPadMinIroc, fkNPadMaxIroc); fHistList->Add(fHistIROC);
456 fHistOROC = new TH2F("fHistOROC" ,"fHistOROC" ,fkNRowsOroc,0,fkNRowsOroc,fkNPadsOroc, fkNPadMinOroc, fkNPadMaxOroc); fHistList->Add(fHistOROC);
458 fHistIROCIndex = new TH2S("fHistIROCIndex" ,"fHistIROCIndex" ,fkNRowsIroc,0,fkNRowsIroc,fkNPadsIroc, fkNPadMinIroc, fkNPadMaxIroc); fHistList->Add(fHistIROCIndex);
459 fHistOROCIndex = new TH2S("fHistOROCIndex" ,"fHistOROCIndex" ,fkNRowsOroc,0,fkNRowsOroc,fkNPadsOroc, fkNPadMinOroc, fkNPadMaxOroc); fHistList->Add(fHistOROCIndex);
461 fHistIROCTime = new TH2F("fHistIROCTime" ,"fHistIROCTime" ,fkNRowsIroc,0,fkNRowsIroc,fkNPadsIroc, fkNPadMinIroc, fkNPadMaxIroc); fHistList->Add(fHistIROCTime);
462 fHistOROCTime = new TH2F("fHistOROCTime" ,"fHistOROCTime" ,fkNRowsOroc,0,fkNRowsOroc,fkNPadsOroc, fkNPadMinOroc, fkNPadMaxOroc); fHistList->Add(fHistOROCTime);
464 fHistIROCRMS = new TH2F("fHistIROCRMS" ,"fHistIROCRMS" ,fkNRowsIroc,0,fkNRowsIroc,fkNPadsIroc, fkNPadMinIroc, fkNPadMaxIroc); fHistList->Add(fHistIROCRMS);
465 fHistOROCRMS = new TH2F("fHistOROCRMS" ,"fHistOROCRMS" ,fkNRowsOroc,0,fkNRowsOroc,fkNPadsOroc, fkNPadMinOroc, fkNPadMaxOroc); fHistList->Add(fHistOROCRMS);
467 fHistIROCSUM = new TH2F("fHistIROCSUM" ,"fHistIROCSUM" ,fkNRowsIroc,0,fkNRowsIroc,fkNPadsIroc, fkNPadMinIroc, fkNPadMaxIroc); fHistList->Add(fHistIROCSUM);
468 fHistOROCSUM = new TH2F("fHistOROCSUM" ,"fHistOROCSUM" ,fkNRowsOroc,0,fkNRowsOroc,fkNPadsOroc, fkNPadMinOroc, fkNPadMaxOroc); fHistList->Add(fHistOROCSUM);
470 fHistIROCBASE = new TH2F("fHistIROCBASE" ,"fHistIROCBASE" ,fkNRowsIroc,0,fkNRowsIroc,fkNPadsIroc, fkNPadMinIroc, fkNPadMaxIroc); fHistList->Add(fHistIROCBASE);
471 fHistOROCBASE = new TH2F("fHistOROCBASE" ,"fHistOROCBASE" ,fkNRowsOroc,0,fkNRowsOroc,fkNPadsOroc, fkNPadMinOroc, fkNPadMaxOroc); fHistList->Add(fHistOROCBASE);
474 fHistChannelTime = new TH2F("fHistChannelTime" ,"fHistChannelTime" ,GetNumOfChannels(),0,GetNumOfChannels(),GetTimeBins(),0,GetTimeBins());fHistList->Add(fHistChannelTime);
475 fHistAddrMapIndex = new TH1F("fHistAddrMapIndex" ,"fHistAddrMapIndex" ,GetMaxHwAddr() ,0,GetMaxHwAddr()); fHistList->Add(fHistAddrMapIndex);
476 fHistAddrMaxAdc = new TH1F("fHistAddrMaxAdc" ,"fHistAddrMaxAdc" ,GetMaxHwAddr(),0,GetMaxHwAddr()); fHistList->Add(fHistAddrMaxAdc);
477 fHistAddrMaxAdcX = new TH1F("fHistAddrMaxAdcX" ,"fHistAddrMaxAdcX" ,GetMaxHwAddr(),0,GetMaxHwAddr()); fHistList->Add(fHistAddrMaxAdcX);
478 fHistAddrBaseMean = new TH1F("fHistAddrBaseMean" ,"fHistAddrBaseMean" ,GetMaxHwAddr(),0,GetMaxHwAddr()); fHistList->Add(fHistAddrBaseMean);
479 fHistAddrAdcSum = new TH1F("fHistAddrAdcSum" ,"fHistAddrAdcSum" ,GetMaxHwAddr(),0,GetMaxHwAddr()); fHistList->Add(fHistAddrAdcSum);
480 fHistAddrBaseRms = new TH1F("fHistAddrBaseRms" ,"fHistAddrBaseRms" ,GetMaxHwAddr(),0,GetMaxHwAddr()); fHistList->Add(fHistAddrBaseRms);
481 fHistDistrSumIROC = new TH1F("fHistDistrSumIROC" ,"fHistDistrSumIROC" ,400,0.0,4000.0); fHistList->Add(fHistDistrSumIROC);
482 fHistDistrMaxIROC = new TH1F("fHistDistrMaxIROC" ,"fHistDistrMaxIROC" ,500,0.0,1000.0); fHistList->Add(fHistDistrMaxIROC);
483 fHistDistrSumOROC = new TH1F("fHistDistrSumOROC" ,"fHistDistrSumOROC" ,400,0.0,4000.0); fHistList->Add(fHistDistrSumOROC);
484 fHistDistrMaxOROC = new TH1F("fHistDistrMaxOROC" ,"fHistDistrMaxOROC" ,500,0.0,1000.0); fHistList->Add(fHistDistrMaxOROC);
486 fHistDistrBase2dIROC = new TH2F("fHistDistrBase2dIROC" ,"fHistDistrBase2dIROC",100,0.0,100.0,100,0.0,10.0); fHistList->Add(fHistDistrBase2dIROC);
487 fHistDistrBase2dOROC = new TH2F("fHistDistrBase2dOROC" ,"fHistDistrBase2dOROC",100,0.0,100.0,100,0.0,10.0); fHistList->Add(fHistDistrBase2dOROC);
489 fHistGlobalMaxA = new TH2S("SIDE A" ,"SIDE A" ,500,-3000,3000,500,-3000,3000); fHistList->Add(fHistGlobalMaxA);
490 fHistGlobalMaxC = new TH2S("SIDE C" ,"SIDE C" ,500,-3000,3000,500,-3000,3000); fHistList->Add(fHistGlobalMaxC);
494 //____________________________________________________________________________
495 Int_t AliTPCMonitor::ProcessEvent()
498 // Depending on the value of the sector id all sectors (sectorid == -1) are processed.
500 // In this case only the maximum values are calculated per pad and filled to the global histograms
501 // In a second loop the last processed(displayed) sector will be processed (sectorid!=-1)
502 // again and the baseline rms and further quantities are calculated
504 // If only one sector should be processed SetProcOneSector(1) should be set.
505 // In this case only the specified (last/last displayed) sector will be processed.
507 // If GetProcNextEvent()==0 the same event will be processed again
511 Int_t retflag = 0; // id of last sector + 1000, or error flag
512 if(GetProcNextEvent()==1 && fLastEv) { AliInfo("Last event already processed"); }
513 if(GetProcNextEvent()==1) ResetSectorArray();
516 if(GetProcNextEvent()==0 || GetProcOneSector()==1 ) sectorid = GetLastSector();
520 retflag = ReadDataNew(sectorid);
522 SetLastProcFile(GetFile());
524 if(retflag>=10 && retflag<1000){ AliError("Could not read event properly: Check file name and format or try next event"); return 0 ;}
529 if(sectorid==-1 && retflag >1000)
531 AliInfo("Second read cycle");
533 if(GetLastSectorDisplayed()==-1) {sectorid = GetLastSector() ; }
534 else {sectorid = GetLastSectorDisplayed(); SetLastSector(sectorid) ; }
535 retflag = ReadDataNew(sectorid);
538 SetLastSectorDisplayed(sectorid) ;
539 fMapHand->ReadfecHwMap(GetLastSector());
542 SetEventProcessed(1);
545 //__________________________________________________________________
546 Int_t AliTPCMonitor::ReadDataNew(Int_t secid)
548 // Read Data File/Stream for specified Format.
549 // Payload will be extracted from either ROOT or DATE format
550 // and passed to FillHistsDecode for decoding of the adc information
553 fRawReader = AliRawReader::Create(GetFile());
554 SetLastProcFile(GetFile());
555 } else if (strcmp(GetLastProcFile(),GetFile())!=0){
557 fRawReader = AliRawReader::Create(GetFile());
558 // printf("New file!!!\n");
559 SetLastProcFile(GetFile());
563 AliWarning("Coult not initialize raw reader");
568 while(skip && GetProcNextEvent())
570 if(fVerb) cout << "AliTPCMonitor::ReadDataNew get event " << endl;
571 if(fRawReader->IsA()==AliRawReaderRoot::Class()){
572 printf("Root, NextEvent: %d\n",GetEventID());
573 if (!fRawReader->GotoEvent(GetEventID())){AliError("Could not get next Event"); return 11 ;}
574 } else if(!fRawReader->NextEvent()) { AliError("Could not get next Event"); return 11 ;}
575 // skip all events but physics, calibration and software trigger events!
576 UInt_t eventType=fRawReader->GetType();
577 if ( !(eventType==AliRawEventHeaderBase::kPhysicsEvent ||
578 eventType==AliRawEventHeaderBase::kCalibrationEvent ||
579 eventType==AliRawEventHeaderBase::kSystemSoftwareTriggerEvent ||
580 eventType==AliRawEventHeaderBase::kDetectorSoftwareTriggerEvent) ) {
581 if (fVerb) cout<< "Skipping event! Its neither of 'physics, calibration and software trigger event'" << endl;
582 if(fRawReader->IsA()==AliRawReaderRoot::Class()){
583 if (fEventNumber<fRawReader->GetNumberOfEvents()-1) ++fEventNumber;
584 else {AliError("No more events");return 11;}
589 //test if the TPC has data
591 fRawReader->Select("TPC");
592 Int_t eventNr=fRawReader->GetEventIndex();
593 if (!fRawReader->ReadNextData(data)) {
595 printf("%d - %d\n",fEventNumber,fRawReader->GetNumberOfEvents());
596 if(fRawReader->IsA()==AliRawReaderRoot::Class()){
597 if (fEventNumber<fRawReader->GetNumberOfEvents()-1){
599 printf("inc conter\n");
602 AliError("No more events");
607 fEventNumber = eventNr;
608 fEventNumberOld = eventNr;
611 // printf("secid: %d\n",secid);
613 //========================== Histogram filling ======================
615 AliAltroRawStreamV3 *altro=new AliAltroRawStreamV3(fRawReader);
616 altro->SelectRawData("TPC");
621 Int_t nextHwAddress = 0;
629 while ( altro->NextDDL() ){
630 fGdcId = fRawReader->GetGDCId() ;
631 fLdcId = fRawReader->GetLDCId() ;
632 fRunId = fRawReader->GetRunNumber() ;
633 fEqId = fRawReader->GetEquipmentId();
634 rcupatch = GetRCUPatch(fRunId, fEqId);
635 Int_t rcupatchSector=rcupatch%6;
636 lastrcuid = (rcupatch+1000);
637 // printf("RCU patch: %d, LDC: %d, EqId: %d\n",rcupatch, fLdcId, fEqId);
638 if(fLdcIdOld!=fLdcId && fChannelIter!=0) {
641 FillGlobal(GetLastSector());
643 // printf("filled sector: %d\n",GetLastSector());
649 // if (rcupatch/6!=secid) continue;
653 if (!CheckEqId(secid,fEqId)) continue;
654 while ( altro->NextChannel() ){
655 hw=altro->GetHWAddress();
656 nextHwAddress = ( hw + (rcupatchSector<<12) );
657 fPad[fChannelIter][0] = nextHwAddress ;
658 fPadMapHw[nextHwAddress] = fChannelIter ;
660 while ( altro->NextBunch() ){
661 Int_t startTbin = (Int_t)altro->GetStartTimeBin();
662 Int_t bunchlength = (Int_t)altro->GetBunchLength();
663 const UShort_t *sig = altro->GetSignals();
664 for (Int_t iTimeBin = 0; iTimeBin<bunchlength; iTimeBin++){
665 Int_t adc=(Int_t)sig[iTimeBin];
666 Int_t ntime=startTbin-iTimeBin;
667 //fill channel information
668 fPad[fChannelIter][ntime] = adc;
669 if( (adc>maxADC) && (ntime>=GetRangeMaxAdcMin()) && (ntime<GetRangeMaxAdcMax() )) {maxADC = adc;maxx = ntime ;}
670 if( (ntime>=GetRangeSumMin()) && (ntime<GetRangeSumMax() )) {sum+=adc; sumn++;}
674 //get pedestal, noise
675 Float_t pedestal=TMath::Mean(GetRangeBaseMax()-GetRangeBaseMin(),fPad[fChannelIter]+GetRangeBaseMin());
676 Float_t noise =TMath::RMS(GetRangeBaseMax()-GetRangeBaseMin(),fPad[fChannelIter]+GetRangeBaseMin());
677 fHistAddrMaxAdc->SetBinContent(nextHwAddress,maxADC-GetPedestals()*pedestal);
683 fHistDistrBase2dIROC->Fill(pedestal,noise);
684 fHistDistrSumIROC->Fill(sum);
685 fHistDistrMaxIROC->Fill(maxADC-pedestal*GetPedestals());
686 fHistDistrSumIROC->Fill(sum -sumn*pedestal*GetPedestals());
690 fHistDistrBase2dOROC->Fill(pedestal,noise);
691 fHistDistrSumOROC->Fill(sum);
692 fHistDistrMaxOROC->Fill(maxADC-pedestal*GetPedestals());
693 fHistDistrSumOROC->Fill(sum -sumn*pedestal*GetPedestals());
696 fHistAddrAdcSum->SetBinContent( nextHwAddress,sum);
697 fHistAddrMapIndex->SetBinContent(nextHwAddress,fChannelIter);
698 fHistAddrBaseMean->SetBinContent(nextHwAddress,pedestal);
699 fHistAddrMaxAdcX->SetBinContent( nextHwAddress,maxx);
700 fHistAddrBaseRms->SetBinContent( nextHwAddress,noise);
705 SetLastSector(rcupatch/6);
706 if(fChannelIter!=0 && secid==-1 ) SetSectorFilled(rcupatch/6);
710 if(fChannelIter!=0 && secid==-1) { FillGlobal(GetLastSector());}
724 //____________________________________________________________________________
725 void AliTPCMonitor::FillHistsPadPlane()
727 // Fill 2Dim histograms for IROC and OROC (max , rms and sum)
729 if(fVerb)cout << "AliTPCMonitor::FillHistsPadPlane() Start " << endl;
730 if(fVerb)PrintConfig();
737 for(Int_t ch = 0; ch<fChannelIter; ch++)
740 fHistChannelTime->SetCellContent(ch,0,hwadd);
742 for(Int_t bin = 1; bin <GetTimeBins(); bin++)
744 if( fHistChannelTime->GetCellContent(ch,bin)!=0) cout << " cellcontent already set " << endl;
745 if( GetPedestals()==1 ) fHistChannelTime->SetCellContent(ch,bin,(fPad[ch][bin]- fHistAddrBaseMean->GetBinContent(hwadd)));
746 else fHistChannelTime->SetCellContent(ch,bin,(fPad[ch][bin]));
749 pad = fMapHand->GetPad( hwadd);
750 row = fMapHand->GetPadRow(hwadd);
751 padmax = fMapHand->GetNumofPads(row);
755 fHistIROC->SetCellContent( row +1 ,pad +55 -padmax/2 +1,fHistAddrMaxAdc->GetBinContent( hwadd));
756 fHistIROCIndex->SetCellContent(row +1 ,pad +55 -padmax/2 +1,ch);
757 fHistIROCRMS->SetCellContent( row +1 ,pad +55 -padmax/2 +1,fHistAddrBaseRms->GetBinContent( hwadd));
758 fHistIROCBASE->SetCellContent( row +1 ,pad +55 -padmax/2 +1,fHistAddrBaseMean->GetBinContent(hwadd));
759 fHistIROCSUM->SetCellContent( row +1 ,pad +55 -padmax/2 +1,fHistAddrAdcSum->GetBinContent( hwadd));
763 fHistOROC->SetCellContent( row-63 +1 ,pad +70 -padmax/2 +1,fHistAddrMaxAdc->GetBinContent( hwadd));
764 fHistOROCIndex->SetCellContent(row-63 +1 ,pad +70 -padmax/2 +1,ch);
765 fHistOROCRMS->SetCellContent( row-63 +1 ,pad +70 -padmax/2 +1,fHistAddrBaseRms->GetBinContent( hwadd));
766 fHistOROCBASE->SetCellContent( row-63 +1 ,pad +70 -padmax/2 +1,fHistAddrBaseMean->GetBinContent(hwadd));
767 fHistOROCSUM->SetCellContent( row-63 +1 ,pad +70 -padmax/2 +1,fHistAddrAdcSum->GetBinContent( hwadd));
771 fHistChannelTime->GetXaxis()->SetRange(0,fChannelIter);
772 fHistChannelTime->GetYaxis()->SetRange(0,GetTimeBins());
777 //____________________________________________________________________________
778 void AliTPCMonitor::ResetArrays()
781 for(Int_t row = 0 ; row < fkNRowsIroc; row++)
783 for(Int_t pad = 0 ; pad < fkNPadsIroc ; pad++)
785 fHistIROCIndex->SetCellContent(row+1,pad+1,-1);
788 for(Int_t row = 0 ; row < fkNRowsOroc; row++)
790 for(Int_t pad = 0 ; pad < fkNPadsOroc ; pad++)
792 fHistOROCIndex->SetCellContent(row+1,pad+1,-1);
796 for(Int_t ch= 0; ch<GetMaxHwAddr(); ch++)
798 fHistAddrMaxAdcX->SetBinContent(ch,-1);
799 fHistAddrMapIndex->SetBinContent(ch,-1);
800 fHistAddrMaxAdc->SetBinContent( ch, 0);
801 fHistAddrBaseMean->SetBinContent( ch, 0);
802 fHistAddrAdcSum->SetBinContent( ch, 0);
803 fHistAddrBaseRms->SetBinContent(ch, 0);
806 for(Int_t ch = 0; ch< GetNumOfChannels(); ch++)
808 for(Int_t bin = 0; bin< GetTimeBins(); bin++)
813 for(Int_t ch = 0; ch< GetMaxHwAddr(); ch++)
816 fPadMapRCU[ch][0]=-1;
817 fPadMapRCU[ch][1]=-1;
818 fPadMapRCU[ch][2]=-1;
819 fPadMapRCU[ch][3]=-1;
820 fPadMapRCU[ch][4]=-1;
821 fPadMapRCU[ch][5]=-1;
827 //____________________________________________________________________________
828 void AliTPCMonitor::ResetHistos()
831 for(Int_t i =0; i<fHistList->GetEntries(); i++)
833 if(GetProcNextEvent()==0 && strcmp(((TH1*)fHistList->At(i))->GetName(),"SIDE A")==0) continue;
834 if(GetProcNextEvent()==0 && strcmp(((TH1*)fHistList->At(i))->GetName(),"SIDE C")==0) continue;
835 ((TH1*)fHistList->At(i))->Reset();
840 //____________________________________________________________________________
841 void AliTPCMonitor::DeleteHistos()
844 for(Int_t i =0; i<fHistList->GetEntries(); i++)
846 delete (TH1*)fHistList->At(i);
851 //__________________________________________________________________
852 Int_t AliTPCMonitor::CheckEqId(Int_t secid,Int_t eqid)
854 // Check if equipment id corresponds to any rcu patch in sector
855 // Equipment ids changed during commisioning in 2006 (starting from run 704)
856 // However Runids started from 0 again in 2007
857 // Now only runids from commissioning in 2006 after runid 704 and all new ones are supported.
858 // Comment in equipment check for runids < 704 if old runs should be processed
860 if(fVerb) cout << "AliTPCMonitor::CheckEqId : SectorId " << secid << " EquipmentId " << eqid << " runid " << fRunId << endl;
862 //skip all eqids which do not belong to the TPC
863 if ( eqid<768||eqid>983 ) return 0;
865 if(fRunId<704 && 0) // commented out --> runs with runid < 704 in 2006 are not recognized anymore
867 if( (secid>-1) && (secid<36) ) // if ( secid is in range) { take only specific eqids} else { take all }
869 if( (secid==13) && ( eqid!=408 && eqid!=409 && eqid!=509 && eqid!=512 && eqid!=513 && eqid!=517 )) {passed=0;}
870 else if( (secid==4) && ( eqid!=404 && eqid!=504 && eqid!=407 && eqid!=503 && eqid!=508 && eqid!=506 )) {passed=0;}
872 else {if(fVerb) cout << "passed check "<< endl; }
876 if( (secid>-1) && (secid<36) ) // if ( secid is in range) { take only specific eqids} else { take all }
878 if(eqid!=fMapEqidsSec[secid][0] && eqid!= fMapEqidsSec[secid][1] && eqid!=fMapEqidsSec[secid][2] &&
879 eqid!=fMapEqidsSec[secid][3] && eqid!= fMapEqidsSec[secid][4] && eqid!=fMapEqidsSec[secid][5] ) {passed=0;}
881 else {if(fVerb) cout << "passed check "<< endl;}
887 //__________________________________________________________________
888 void AliTPCMonitor::SetEqIds()
890 // Set mapping for equipment ids
891 for(Int_t i = 0; i<36 ; i++)
893 for(Int_t j = 0; j<6; j++)
895 if(j<2) fMapEqidsSec[i][j]= 768+i*2+j;
896 else fMapEqidsSec[i][j]= 840+i*4+j-2;
900 for(Int_t i = 0; i<36 ; i++)
902 for(Int_t j = 0; j<6; j++)
904 if(j<2) fMapEqidsRcu[768+i*2+j] = i*6 +j;
905 else fMapEqidsRcu[840+i*4+j-2] = i*6 +j;
910 //__________________________________________________________________
911 void AliTPCMonitor::FillGlobal(Int_t sector)
914 // Fill global histograms with max adc for each channel
917 if((sector/18) ==0) hglob = fHistGlobalMaxA;
918 else hglob = fHistGlobalMaxC;
920 Float_t rotsec = (2*TMath::Pi()/18.0);
921 Float_t rot = (-rotsec*(sector%18) +4*rotsec);
923 Float_t m11 = TMath::Cos(rot);
924 Float_t m12 = TMath::Sin(rot);
925 Float_t m21 = -1*TMath::Sin(rot);
926 Float_t m22 = TMath::Cos(rot);
928 Int_t max = 0; // use integer for global view
940 for(Int_t hw = 0; hw<fHistAddrMaxAdc->GetNbinsX(); hw++)
942 max = (Int_t)fHistAddrMaxAdc->GetBinContent(hw);
945 pad = fMapHand->GetPad( hw);
946 row = fMapHand->GetPadRow(hw);
947 padmax = fMapHand->GetNumofPads(row);
948 if (sector%36>17) fMirror=-1;
950 GetXY(xval ,yval , padmax,row ,pad);
951 xdr = xval*m11 +yval*m12;
952 ydr = xval*m21 +yval*m22;
953 if(hglob->GetBinContent(hglob->GetXaxis()->FindBin(xdr),hglob->GetYaxis()->FindBin(ydr))==0) hglob->Fill(xdr,ydr,(Int_t)max);
959 //__________________________________________________________________
960 void AliTPCMonitor::GetXY( Double_t& xval , Double_t& yval , Int_t padmax, Int_t row , Int_t pad) const
962 // Get x and y position of pad
966 xval = fMirror*( 2*padmax -4*pad -2);
967 yval = 852.25 +7.5*row;
971 xval = fMirror*( 3*padmax -6*pad -3);
972 if((row-63)<63) { yval = 10*(row-63) +1351; }
973 else { yval = 15*(row-63-64)+1993.5; }
978 //__________________________________________________________________
979 Int_t AliTPCMonitor::GetPadAtX(Float_t xval, Int_t row, Int_t padmax) const
981 // Get pad number at given position in x
984 if(row<63) {pad = (Int_t)( ( (xval/fMirror) +2 -2*padmax)/-4);}
985 else {pad = (Int_t)( ( (xval/fMirror) +3 -3*padmax)/-6);}
987 if(pad>=padmax) return -1;
992 //__________________________________________________________________
993 Int_t AliTPCMonitor::GetPadAtX(Float_t xval, Int_t row) const
996 // Get pad number at given position in x
998 Int_t padmax = fMapHand->GetNumofPads(row);
1001 if(row<63) {pad = (Int_t)( ( (xval/fMirror) +2 -2*padmax)/-4);}
1002 else {pad = (Int_t)( ( (xval/fMirror) +3 -3*padmax)/-6);}
1004 if(pad>=padmax) return -1;
1009 //__________________________________________________________________
1010 void AliTPCMonitor::DrawHists(Int_t histos)
1013 // Draw sets of histograms
1014 // histos==1 : 2Dim histos for MAX adc and add executables
1015 // histos==2 : distributions max/rms/sum
1016 // histos==3 : global max adc for specified SideA/C
1019 if(fVerb) cout << " Draw histos " << endl;
1021 if(GetLastSector()/18==0 ) sprintf(cside,"A");
1022 else sprintf(cside,"C");
1024 Char_t titleSEC[256]; sprintf(titleSEC ,"Sector %i Side %s Run : %05i EventID %i " ,GetLastSector()%18,cside,fRunId, fEventNumber);
1025 Char_t titleEvent[256]; sprintf(titleEvent ,"Time <-> Channles %s" ,titleSEC);
1026 Char_t titleIROC[256]; sprintf(titleIROC ,"IROC %s" ,titleSEC);
1027 Char_t titleOROC[256]; sprintf(titleOROC ,"OROC %s" ,titleSEC);
1029 Char_t titleMAX[256]; sprintf(titleMAX ,"Max (timebin: %i,%i) %s" ,GetRangeMaxAdcMin(),GetRangeMaxAdcMax(),titleSEC);
1030 Char_t titleSUM[256]; sprintf(titleSUM ,"Sum (timebin: %i,%i) %s" ,GetRangeSumMin() ,GetRangeSumMax() ,titleSEC);
1031 Char_t titleBASE[256]; sprintf(titleBASE ,"Baseline RMS<->Mean (timebin: %i-%i) %s" ,GetRangeBaseMin() ,GetRangeBaseMax() ,titleSEC);
1032 Char_t titleMEAN[256]; sprintf(titleMEAN ,"Baseline Mean (timebin: %i-%i) %s" ,GetRangeBaseMin() ,GetRangeBaseMax() ,titleSEC);
1033 Char_t titleRMS[256] ; sprintf(titleRMS ,"Baseline RMS (timebin: %i-%i) %s" ,GetRangeBaseMin() ,GetRangeBaseMax() ,titleSEC);
1037 // IROC _______________________________________________________________
1039 ciroc = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("ciroc");
1042 ciroc = CreateCanvas("ciroc");
1047 fHistIROC->SetXTitle("row");
1048 fHistIROC->SetYTitle("pad");
1049 if(GetPedestals()) fHistIROC->SetZTitle("max ADC (baseline sub)");
1050 else fHistIROC->SetZTitle("max ADC ");
1051 fHistIROC->SetTitle(titleIROC);
1052 fHistIROC->SetMinimum(0.01);
1053 fHistIROC->Draw("COLZ");
1054 ciroc->UseCurrentStyle();
1057 fHistIROCTime->SetXTitle("row"); fHistIROCTime->SetZTitle("peak time (fit)"); fHistIROCTime->SetYTitle("pad"); fHistIROCTime->SetTitle(titleIROC);
1058 fHistIROCRMS->SetXTitle("row"); fHistIROCRMS->SetZTitle( "baseline rms (ADC)"); fHistIROCRMS->SetYTitle("pad"); fHistIROCRMS->SetTitle(titleIROC);
1062 coroc =(TCanvas*)gROOT->GetListOfCanvases()->FindObject("coroc");
1064 coroc = CreateCanvas("coroc");
1069 fHistOROC->SetXTitle("row");
1070 fHistOROC->SetYTitle("pad");
1071 if(GetPedestals()) fHistOROC->SetZTitle("max ADC (baseline sub)");
1072 else fHistOROC->SetZTitle("max ADC ");
1073 fHistOROC->SetTitle(titleOROC);
1074 fHistOROC->SetMinimum(0.01);
1075 fHistOROC->Draw("COLZ");
1076 coroc->UseCurrentStyle();
1079 fHistOROCTime->SetXTitle("row"); fHistOROCTime->SetZTitle("peak time (fit) (timebins)"); fHistOROCTime->SetYTitle("pad"); fHistOROCTime->SetTitle(titleOROC);
1080 fHistOROCRMS->SetXTitle("row"); fHistOROCRMS->SetZTitle("baseline rms (ADC)"); fHistOROCRMS->SetYTitle("pad"); fHistOROCRMS->SetTitle(titleOROC);
1083 Char_t namesum[256] ; sprintf(namesum,"ADC sum (bins: %i, %i)",GetRangeSumMin() ,GetRangeSumMax() );
1084 fHistIROCSUM->SetXTitle("row"); fHistIROCSUM->SetZTitle(namesum); fHistIROCSUM->SetYTitle("pad"); fHistIROCSUM->SetTitle(titleIROC);
1085 fHistOROCSUM->SetXTitle("row"); fHistOROCSUM->SetZTitle(namesum); fHistOROCSUM->SetYTitle("pad"); fHistOROCSUM->SetTitle(titleOROC);
1088 Char_t namebase[256] ; sprintf(namebase ,"base mean (timbebin: %i, %i )",GetRangeBaseMin(),GetRangeBaseMax());
1089 fHistIROCBASE->SetXTitle("row"); fHistIROCBASE->SetZTitle(namebase); fHistIROCBASE->SetYTitle("pad"); fHistIROCBASE->SetTitle(titleIROC);
1090 fHistOROCBASE->SetXTitle("row"); fHistOROCBASE->SetZTitle(namebase); fHistOROCBASE->SetYTitle("pad"); fHistOROCBASE->SetTitle(titleOROC);
1092 if(fHistIROCClone) fHistIROCClone->Delete();
1093 if(fHistOROCClone) fHistOROCClone->Delete();
1094 fHistIROCClone = (TH2F*)fHistIROC->Clone("fHistIROCClone");
1095 fHistOROCClone = (TH2F*)fHistOROC->Clone("fHistOROCClone");
1098 if(fExecPlaneMax==0)
1101 sprintf(carry1,".x %s/TPC/AliTPCMonitorExec.C(1)",gSystem->Getenv("ALICE_ROOT"));
1102 ciroc->AddExec("pad",carry1);
1103 coroc->AddExec("pad",carry1);
1106 sprintf(carry2,".x %s/TPC/AliTPCMonitorExec.C(2)",gSystem->Getenv("ALICE_ROOT"));
1107 ciroc->AddExec("row",carry2);
1108 coroc->AddExec("row",carry2);
1116 // MAX ADC distribution ____________________________________________
1118 cmax = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("cmax");
1119 if(!cmax) cmax = CreateCanvas("cmax");
1122 fHistDistrMaxIROC->GetXaxis()->SetRangeUser(0.0,1000.0);
1123 fHistDistrMaxIROC->SetXTitle("max ADC (ADC)");
1124 fHistDistrMaxIROC->SetYTitle("counts");
1125 fHistDistrMaxIROC->SetTitle(titleMAX);
1126 fHistDistrMaxIROC->Draw("");
1127 fHistDistrMaxOROC->SetLineColor(2);
1128 fHistDistrMaxOROC->Draw("same");
1130 if(fHistDistrMaxOROC->GetMaximum()> fHistDistrMaxIROC->GetMaximum()) fHistDistrMaxIROC->SetMaximum(fHistDistrMaxOROC->GetMaximum()*1.1);
1132 TLegend* legio = new TLegend(0.6,0.6,0.8,0.8);
1133 legio->SetFillColor(0);
1134 legio->AddEntry(fHistDistrMaxIROC,"IROC","l");
1135 legio->AddEntry(fHistDistrMaxOROC,"OROC","l");
1136 legio->Draw("same");
1138 // ADC sum distribution
1140 csum = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("csum");
1141 if(!csum) csum = CreateCanvas("csum") ;
1144 fHistDistrSumIROC->SetXTitle("sum ADC (ADC)");
1145 fHistDistrSumIROC->SetYTitle("counts");
1146 fHistDistrSumIROC->SetTitle(titleSUM);
1147 fHistDistrSumIROC->Draw("");
1148 fHistDistrSumOROC->SetLineColor(2);
1149 fHistDistrSumOROC->Draw("same");
1150 if(fHistDistrSumOROC->GetMaximum()> fHistDistrSumIROC->GetMaximum()) fHistDistrSumIROC->SetMaximum(fHistDistrSumOROC->GetMaximum()*1.1);
1151 legio->Draw("same");
1153 // BASELINE MEAN distribution
1154 TCanvas* cbasemean = 0;
1155 cbasemean = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("cbasemean");
1156 if(!cbasemean) cbasemean = CreateCanvas("cbasemean");
1159 fHistDistrBaseMeanIROC = fHistDistrBase2dIROC->ProjectionX("fHistDistrBaseMeanIROC");
1160 fHistDistrBaseMeanIROC->SetXTitle("base mean (ADC)");
1161 fHistDistrBaseMeanIROC->SetYTitle("counts");
1162 fHistDistrBaseMeanIROC->SetTitle(titleMEAN);
1163 fHistDistrBaseMeanIROC->Draw("");
1165 fHistDistrBaseMeanOROC = fHistDistrBase2dOROC->ProjectionX("fHistDistrBaseMeanOROC");
1166 fHistDistrBaseMeanOROC->SetLineColor(2);
1167 fHistDistrBaseMeanOROC->Draw("same");
1168 if(fHistDistrBaseMeanOROC->GetMaximum()>fHistDistrBaseMeanIROC->GetMaximum()) fHistDistrBaseMeanIROC->SetMaximum(fHistDistrBaseMeanOROC->GetMaximum()*1.1);
1169 legio->Draw("same");
1171 TCanvas* cbaserms = 0;
1172 cbaserms = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("cbaserms");
1173 if(!cbaserms) cbaserms = CreateCanvas("cbaserms") ;
1176 // BASELINE RMS distribution
1177 fHistDistrBaseRmsIROC = fHistDistrBase2dIROC->ProjectionY("fHistDistrBaseRmsIROC");
1178 fHistDistrBaseRmsIROC->SetXTitle("base rms (ADC)");
1179 fHistDistrBaseRmsIROC->SetYTitle("counts");
1180 fHistDistrBaseRmsIROC->SetTitle(titleRMS);
1181 fHistDistrBaseRmsIROC->Draw("");
1183 fHistDistrBaseRmsOROC = fHistDistrBase2dOROC->ProjectionY("fHistDistrBaseRmsOROC");
1184 fHistDistrBaseRmsOROC->SetLineColor(2);
1185 fHistDistrBaseRmsOROC->Draw("same");
1186 if(fHistDistrBaseRmsOROC->GetMaximum()>fHistDistrBaseRmsIROC->GetMaximum()) fHistDistrBaseRmsIROC->SetMaximum(fHistDistrBaseRmsOROC->GetMaximum()*1.1);
1187 legio->Draw("same");
1191 cbasemean->Update();
1196 // GLOBAL MAX ADC _________________________________
1197 if(GetProcNextEvent()==1)
1202 if(!(cglobC=(TCanvas*)gROOT->GetListOfCanvases()->FindObject("SIDE C all"))) cglobC = CreateCanvas("SIDE C all");
1203 if(!(cglobA=(TCanvas*)gROOT->GetListOfCanvases()->FindObject("SIDE A all"))) cglobA = CreateCanvas("SIDE A all");
1205 Char_t globtitle1[256]; sprintf(globtitle1,"SIDE A Run %05i (EventID %i)",fRunId,fEventNumber);
1206 Char_t globtitle2[256]; sprintf(globtitle2,"SIDE C Run %05i (EventID %i)",fRunId,fEventNumber);
1208 fHistGlobalMaxA->SetTitle(globtitle1);
1209 fHistGlobalMaxC->SetTitle(globtitle2);
1210 fHistGlobalMaxA->SetXTitle("x/mm");
1211 fHistGlobalMaxA->SetYTitle("y/mm");
1212 fHistGlobalMaxC->SetXTitle("x/mm");
1213 fHistGlobalMaxC->SetYTitle("y/mm");
1215 if(GetPedestals()==0) { fHistGlobalMaxA->SetZTitle("max adc (not baseline sub)"); fHistGlobalMaxC->SetZTitle("max adc (not baseline sub)"); }
1216 else { fHistGlobalMaxA->SetZTitle("max adc "); fHistGlobalMaxC->SetZTitle("max adc "); }
1218 fHistGlobalMaxA->SetMinimum(0.01);
1219 fHistGlobalMaxC->SetMinimum(0.01);
1221 cglobC->cd() ; fHistGlobalMaxC->Draw("COLZ");
1222 cglobA->cd() ; fHistGlobalMaxA->Draw("COLZ");
1225 sprintf(nameom,".x %s/TPC/AliTPCMonitorExec.C(3)",gSystem->Getenv("ALICE_ROOT"));
1229 if(fVerb)cout << " set exec " << nameom << endl;
1230 cglobC->AddExec("glob",nameom);
1231 cglobA->AddExec("glob",nameom);
1236 cglobC->DeleteExec("glob");
1237 cglobA->DeleteExec("glob");
1239 if(fVerb) cout << " set exec " << nameom << endl;
1240 cglobC->AddExec("glob",nameom);
1241 cglobA->AddExec("glob",nameom);
1253 //__________________________________________________________________
1254 void AliTPCMonitor::DrawRMSMap()
1256 // Draw 2Dim rms histos for IROC and OROC
1257 // and set executables for canvases
1259 TCanvas* crmsoroc =0;
1260 TCanvas* crmsiroc =0;
1261 if(!(crmsoroc = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("crmsoroc"))) crmsoroc = CreateCanvas("crmsoroc");
1262 if(!(crmsiroc = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("crmsiroc"))) crmsiroc = CreateCanvas("crmsiroc");
1264 crmsiroc->cd(); fHistIROCRMS->Draw("COLZ");
1265 crmsoroc->cd(); fHistOROCRMS->Draw("COLZ");
1267 Char_t carry1[100]; sprintf(carry1,".x %s/TPC/AliTPCMonitorExec.C(1)",gSystem->Getenv("ALICE_ROOT"));
1268 Char_t carry2[100]; sprintf(carry2,".x %s/TPC/AliTPCMonitorExec.C(2)",gSystem->Getenv("ALICE_ROOT"));
1270 if(fExecPadIrocRms==0)
1272 crmsiroc->AddExec("pad",carry1);
1273 crmsiroc->AddExec("row",carry2);
1277 if(fExecPadOrocRms==0)
1279 crmsoroc->AddExec("pad",carry1);
1280 crmsoroc->AddExec("row",carry2);
1291 //__________________________________________________________________
1292 void AliTPCMonitor::ExecPad()
1295 // Executable for Pad
1296 // Show time profile for channel the mouse is pointing at
1298 Int_t event = gPad->GetEvent();
1299 if (event != 51) return;
1301 TObject *select = gPad->GetSelected();
1303 if(!select->InheritsFrom("TH2")) { return; }
1304 gPad->GetCanvas()->FeedbackMode(kTRUE);
1307 Int_t px = gPad->GetEventX();
1308 Int_t py = gPad->GetEventY();
1309 Float_t upy = gPad->AbsPixeltoY(py);
1310 Float_t upx = gPad->AbsPixeltoX(px);
1311 Float_t y = gPad->PadtoY(upy);
1312 Float_t x = gPad->PadtoX(upx);
1317 // Char_t namehist[50];
1318 Char_t projhist[60];
1319 Char_t namesel[256];
1320 Char_t namecanv[256];
1324 Float_t ybinmin = 0;
1325 Float_t ybinmax = 0;
1327 // Check wich Canvas executed the event
1329 sprintf(namesel,select->GetName());
1330 if(strcmp(namesel,"fHistOROC")==0 || strcmp(namesel,"fHistOROCRMS")==0 || strcmp(namesel,"fHistOROCTime")==0 )
1334 sprintf(projhist,"ProjectionOROC");
1335 sprintf(namecanv,"coroc_ch");
1336 fHistIndex = fHistOROCIndex;
1338 if(strcmp(namesel,"fHistIROC")==0 || strcmp(namesel,"fHistIROCRMS")==0 || strcmp(namesel,"fHistIROCTime")==0 )
1342 sprintf(projhist,"ProjectionIROC");
1343 sprintf(namecanv,"ciroc_ch");
1344 fHistIndex = fHistIROCIndex;
1347 // Check if Canvas already existed and get Ranges from former Prjection histogram
1348 if((cpad=(TCanvas*)gROOT->GetListOfCanvases()->FindObject(namecanv)))
1351 if(gROOT->Get(projhist))
1354 xbinmin = ((TH1D*)gROOT->Get(projhist))->GetXaxis()->GetFirst();
1355 xbinmax = ((TH1D*)gROOT->Get(projhist))->GetXaxis()->GetLast();
1356 ybinmin = ((TH1D*)gROOT->Get(projhist))->GetMinimum();
1357 ybinmax = ((TH1D*)gROOT->Get(projhist))->GetMaximum();
1358 delete gROOT->Get("legfit");
1359 delete gROOT->Get("fg");
1364 cpad = CreateCanvas(namecanv); cpad->cd();
1368 Int_t testy = fHistIndex->GetYaxis()->FindBin(y);
1369 Int_t testx = fHistIndex->GetXaxis()->FindBin(x);
1370 Int_t binchannel = (Int_t)fHistIndex->GetCellContent(testx,testy);
1371 if(binchannel>30000 || binchannel<0) return;
1373 TH1D *hp=(TH1D*)gROOT->Get(projhist);
1374 if(!hp) hp=new TH1D(projhist,projhist,GetTimeBins(),0,GetTimeBins());//delete gROOT->Get(projhist);
1376 // TH1D *hp = (TH1D*)(((TH1D*)fHistChannelTime->ProjectionY("hp",binchannel,binchannel))->Clone(projhist));
1377 // TH1D *hp = fHistChannelTime->ProjectionY(projhist,binchannel,binchannel);
1379 Int_t nbinsx=fHistChannelTime->GetNbinsX();
1380 for (Int_t itb=0;itb<GetTimeBins();++itb){
1381 hp->GetArray()[itb]=fHistChannelTime->GetArray()[binchannel+itb*(nbinsx+2)];
1386 // Make title and Pave for channel Info
1388 Int_t npadRow , npad , nhw , nmax , hwadd;
1390 hwadd = (Int_t)fHistChannelTime->GetCellContent(binchannel,0);
1391 fPadUsedHwAddr = hwadd;
1393 if(rocid==0)npadRow = fMapHand->GetPadRow(hwadd);
1394 else npadRow = fMapHand->GetPadRow(hwadd)-63;
1395 npad = fMapHand->GetPad(hwadd);
1397 nmax = (Int_t)hp->GetMaximum();
1400 TPaveText* legstat = new TPaveText(0.18,0.65,0.3,0.8,"NDC");
1402 Int_t connector = fMapHand->GetFECconnector(hwadd);
1403 Int_t fecnr = fMapHand->GetFECfromHw(hwadd);
1404 Int_t fecch = fMapHand->GetFECchannel(hwadd);
1405 Int_t altrochip = fMapHand->GetAltro(hwadd);
1406 Int_t altrochannel= (fMapHand->GetAltroChannel(hwadd))%16;
1407 Int_t fecloc = fMapHand->U2fGetFECinRCU(fecnr) ;
1408 Int_t feclocbran = fMapHand->U2fGetFECinBranch(fecnr);
1409 Int_t branch = fMapHand->U2fGetBranch(fecnr);
1412 Short_t fecget = (hwadd & fgkHwMaskFEC) >> 7;
1413 Short_t branchget = (hwadd & fgkHwMaskBranch)>> 11;
1416 Char_t nstat1[100]; Char_t nstat2[100]; Char_t nstat3[100]; Char_t nstat4[100];
1417 Char_t nstat5[100]; Char_t nstat6[100]; Char_t nstat7[100]; Char_t nstat8[100];
1419 sprintf(nstat1,"Branch (map) \t %i (%i) \n",branchget,branch);
1420 sprintf(nstat2,"Fec in patch \t %i \n",fecloc);
1421 sprintf(nstat8,"Fec in branch (map)\t %i (%i)\n",fecget,feclocbran);
1422 sprintf(nstat7,"Connector \t %i \n",connector);
1423 sprintf(nstat3,"Fec No. \t %i \n",fecnr);
1424 sprintf(nstat4,"Fec chan \t %i \n",fecch);
1425 sprintf(nstat5,"Altro chip\t %i \n",altrochip);
1426 sprintf(nstat6,"Altro chan\t %i \n",altrochannel);
1428 legstat->AddText(nstat1); legstat->AddText(nstat2); legstat->AddText(nstat8); legstat->AddText(nstat7);
1429 legstat->AddText(nstat3); legstat->AddText(nstat4); legstat->AddText(nstat5); legstat->AddText(nstat6);
1431 sprintf(title,"Row=%d Pad=%d Hw =%d maxADC =%d count =%d",npadRow,npad,nhw,nmax,binchannel);
1433 // hp->SetName(projhist);
1434 hp->SetTitleSize(0.04);
1435 hp->SetTitle(title);
1436 hp->SetYTitle("ADC");
1437 hp->SetXTitle("Timebin");
1438 hp->GetXaxis()->SetTitleColor(1);
1442 hp->GetXaxis()->SetRange(xbinmin,xbinmax);
1443 hp->SetMinimum(ybinmin);
1444 hp->SetMaximum(ybinmax);
1448 hp->SetMinimum(0.0);
1449 hp->SetMaximum(1000.0);
1456 if(GetPedestals() && fDisableFit==0)
1458 Int_t maxx = (Int_t)fHistAddrMaxAdcX->GetBinContent(hwadd);
1459 Float_t max = (Float_t)fHistAddrMaxAdc->GetBinContent(hwadd);
1460 Float_t base = (Float_t)fHistAddrBaseMean->GetBinContent(hwadd);
1463 if( ((max+base)/base)>1.2)
1465 TF1* fg = new TF1("fg",AliTPCMonitor::Gamma4,maxx-5,maxx+5,4);
1466 fg->SetParName(0,"Normalisation");
1467 fg->SetParName(1,"Minimum");
1468 fg->SetParName(2,"Width");
1469 fg->SetParName(3,"Base");
1470 fg->SetParameter(0,max);
1471 fg->SetParameter(1,maxx-2);
1472 fg->SetParameter(2,1.5);
1473 fg->FixParameter(3,0);
1474 fg->SetLineColor(4);
1475 fg->SetLineWidth(1);
1478 TLegend* legfit = new TLegend(0.6,0.7,0.7,0.8);
1479 legfit->AddEntry("fg","#Gamma 4 fit","l");
1480 legfit->SetFillColor(0);
1481 legfit->SetName("legfit");
1482 legfit->Draw("same");
1486 legstat->SetFillColor(0);
1487 legstat->Draw("same");
1492 //__________________________________________________________________
1493 void AliTPCMonitor::ExecRow()
1496 // Executable for Pad
1497 // Show profile of max adc over given pad row
1498 // and 2dim histo adc(pad-in-row,time bin)
1500 Int_t event = gPad->GetEvent();
1501 if (event != 61) return;
1503 TObject *select = gPad->GetSelected();
1505 if(!select->InheritsFrom("TH2")) { return; }
1508 // Char_t namehist[50];
1510 Char_t rowhistsum[60];
1511 Char_t rowhistmax[60];
1512 Char_t rowhistxmax[60];
1514 sprintf(rowhist, "hrowtime");
1515 sprintf(rowhistxmax ,"hxmax");
1516 sprintf(rowhistmax , "hrowmax");
1519 Int_t px = gPad->GetEventX();
1520 Int_t py = gPad->GetEventY();
1521 Float_t upy = gPad->AbsPixeltoY(py);
1522 Float_t upx = gPad->AbsPixeltoX(px);
1523 Float_t y = gPad->PadtoY(upy);
1524 Float_t x = gPad->PadtoX(upx);
1526 TCanvas*crowtime = 0;
1527 TCanvas*crowmax = 0;
1530 TH2S* fHistIndex = 0;
1532 // ranges from already existing histos
1533 Int_t rowtimexmin = 0;
1534 Int_t rowtimexmax = 0;
1535 Int_t rowtimeymin = 0;
1536 Int_t rowtimeymax = 0;
1537 Float_t rowtimezmin = 0;
1538 Float_t rowtimezmax = 0;
1540 Int_t profrowxmin = 0;
1541 Int_t profrowxmax = 0;
1542 Double_t profrowymin = 0;
1543 Double_t profrowymax = 0;
1545 Int_t profxxmin = 0;
1546 Int_t profxxmax = 0;
1547 Double_t profxymin = 0;
1548 Double_t profxymax = 0;
1554 if( strcmp(select->GetName(),"fHistIROC")==0 || strcmp(select->GetName(),"fHistIROCRMS")==0 ) { fHistIndex = fHistIROCIndex; rocid =1; }
1555 else if(strcmp(select->GetName(),"fHistOROC")==0 || strcmp(select->GetName(),"fHistOROCRMS")==0 ) { fHistIndex = fHistOROCIndex; rocid =2; }
1556 else { cout << " not implemented for this histo " << endl; return; }
1558 gPad->GetCanvas()->FeedbackMode(kTRUE);
1562 // check if canvases exist //
1563 crowtime = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("crowtime");
1564 crowmax = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("crowmax");
1565 cxmax = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("cxmax");
1567 if(!crowtime) crowtime = CreateCanvas("crowtime") ;
1568 if(!crowmax) crowmax = CreateCanvas("crowmax") ;
1569 if(!cxmax ) cxmax = CreateCanvas("cxmax") ;
1571 // check ranges of already existing histos
1572 if(gROOT->Get(rowhist))
1574 rowtimexmin = ((TH2F*)gROOT->Get(rowhist))->GetXaxis()->GetFirst();
1575 rowtimexmax = ((TH2F*)gROOT->Get(rowhist))->GetXaxis()->GetLast();
1576 rowtimeymin = ((TH2F*)gROOT->Get(rowhist))->GetYaxis()->GetFirst();
1577 rowtimeymax = ((TH2F*)gROOT->Get(rowhist))->GetYaxis()->GetLast();
1578 rowtimezmin = ((TH2F*)gROOT->Get(rowhist))->GetMinimum();
1579 rowtimezmax = ((TH2F*)gROOT->Get(rowhist))->GetMaximum();
1581 profrowxmin = ((TH1F*)gROOT->Get(rowhistmax))->GetXaxis()->GetFirst();
1582 profrowxmax = ((TH1F*)gROOT->Get(rowhistmax))->GetXaxis()->GetLast();
1583 profrowymin = ((TH1F*)gROOT->Get(rowhistmax))->GetMinimum();
1584 profrowymax = ((TH1F*)gROOT->Get(rowhistmax))->GetMaximum();
1586 profxxmin = ((TH1F*)gROOT->Get(rowhistxmax))->GetXaxis()->GetFirst();
1587 profxxmax = ((TH1F*)gROOT->Get(rowhistxmax))->GetXaxis()->GetLast();
1588 profxymin = ((TH1F*)gROOT->Get(rowhistxmax))->GetMinimum();
1589 profxymax = ((TH1F*)gROOT->Get(rowhistxmax))->GetMaximum();
1593 delete gROOT->Get(rowhist);
1594 delete gROOT->Get(rowhistmax);
1595 delete gROOT->Get(rowhistsum);
1596 delete gROOT->Get("hxmax");
1597 delete gROOT->Get("legrow");
1600 // get channel for xy bin -> getRow -> getNrows -> getHw for each Pad in Row -> get channel for each hw -> make proj
1601 Int_t testy = fHistIndex->GetYaxis()->FindBin(y);
1602 Int_t testx = fHistIndex->GetXaxis()->FindBin(x);
1603 Int_t binchannel = (Int_t)fHistIndex->GetCellContent(testx,testy);
1605 if(binchannel>30000) return;
1606 if(binchannel<=0 ) { crowtime->Update() ; crowmax->Update() ; return ; }
1609 Int_t hwadd = (Int_t)fHistChannelTime->GetCellContent(binchannel,0);
1610 Int_t row = fMapHand->GetPadRow(hwadd);
1611 Int_t pad = fMapHand->GetPad(hwadd) ;
1612 Int_t numofpads = fMapHand->GetNumofPads(row);
1615 TH2F *hrowtime = new TH2F(rowhist , "" ,numofpads,0,numofpads,GetTimeBins(),0.0,GetTimeBins());
1616 TH1F *hrowmax = new TH1F(rowhistmax , "" ,numofpads,0,numofpads);
1617 TH1F *hxmax = new TH1F(rowhistxmax, "" ,159,0,159 );
1619 // Row profile ///////////
1620 if(fVerb) cout << " Number of pads " << numofpads << endl;
1621 for(Int_t padnr = 0; padnr<numofpads;padnr++)
1623 Int_t addrinrow = fMapHand->GetPadAddInRow(row,padnr );
1624 Int_t channel = (Int_t)fHistAddrMapIndex->GetBinContent(addrinrow);
1625 if(channel==-1) continue;
1627 hrowmax->SetBinContent(padnr+1,fHistAddrMaxAdc->GetBinContent(addrinrow));
1628 TH1D *hp = fHistChannelTime->ProjectionY("hp",channel,channel);
1629 for(Int_t time = 0;time<GetTimeBins();time++) {
1631 Float_t val = hp->GetBinContent(time);
1632 hrowtime->SetCellContent(padnr+1,time+1,val);
1636 // X profile /////////////
1637 Double_t xval = 0.0;
1638 Double_t yval = 0.0;
1639 GetXY(xval,yval,numofpads,row,pad);
1643 for(Int_t nrow = 0; nrow<159; nrow++)
1645 padnr = GetPadAtX(xval,nrow);
1648 hw = fMapHand->GetPadAddInRow(nrow,padnr);
1649 if(fPadMapHw[hw]==-1){ continue ; }
1650 else { hxmax->SetBinContent(nrow+1,fHistAddrMaxAdc->GetBinContent(hw)) ; }
1655 Char_t hxtitle[50] ; sprintf(hxtitle,"max adc in pads at x=%5.1f mm",xval);
1656 hxmax->SetTitle(hxtitle);
1657 hxmax->SetXTitle("row");
1658 if(!GetPedestals()) hxmax->SetYTitle("max adc (baseline sub.)");
1659 else hxmax->SetYTitle("max adc ");
1660 hxmax->SetMinimum(0.01);
1665 hxmax->GetXaxis()->SetRange(profxxmin,profxxmax);
1666 hxmax->SetMinimum(profxymin);
1667 hxmax->SetMaximum(profxymax);
1674 Char_t titlemax[256];
1675 if(rocid==1) {sprintf(title,"%s Row=%d",((TH2*)select)->GetTitle(),row) ; sprintf(titlemax,"IROC max/sum Row=%d",row );}
1676 else {sprintf(title,"%s Row=%d",((TH2*)select)->GetTitle(),row-63); sprintf(titlemax,"OROC max/sum Row=%d",row-63);}
1677 if(fVerb) cout << " set name " << endl;
1682 hrowtime->SetTitleSize(0.04);
1683 hrowtime->SetTitle(title);
1684 hrowtime->SetYTitle("timbin");
1685 hrowtime->SetXTitle("pad in row");
1686 hrowtime->SetZTitle("signal (ADC)");
1688 hrowtime->GetXaxis()->SetTitleColor(1);
1689 hrowtime->SetMaximum(1000.0);
1690 hrowtime->SetMinimum(0.0);
1694 hrowtime->GetXaxis()->SetRange(rowtimexmin,rowtimexmax);
1695 hrowtime->GetYaxis()->SetRange(rowtimeymin,rowtimeymax);
1696 hrowtime->SetMinimum(rowtimezmin);
1697 hrowtime->SetMaximum(rowtimezmax);
1700 hrowtime->Draw("COLZ");
1701 crowtime->UseCurrentStyle();
1704 // max and sum /////////////////////////
1707 hrowmax->GetXaxis()->SetRange(profrowxmin,profrowxmax);
1708 hrowmax->SetMinimum(profrowymin);
1709 hrowmax->SetMaximum(profrowymax);
1711 hrowmax->SetTitleSize(0.04);
1712 hrowmax->SetTitle(title);
1713 hrowmax->SetYTitle("max adc");
1714 hrowmax->SetXTitle("pad in row");
1715 hrowmax->GetXaxis()->SetTitleColor(1);
1717 hrowmax->SetLineColor(2);
1724 //__________________________________________________________________
1725 void AliTPCMonitor::Write10bitChannel()
1728 // Write 10 bit words form histogram for active(last pointed) channel
1730 if(fPadUsedHwAddr==-1){ AliWarning(" No active pad "); return ;}
1732 Int_t pad = (Int_t)fMapHand->GetPad( fPadUsedHwAddr);
1733 Int_t row = (Int_t)fMapHand->GetPadRow(fPadUsedHwAddr);
1734 Int_t channel = (Int_t)fPadMapHw[fPadUsedHwAddr];
1736 Char_t filenameroot[256];
1737 Char_t filenamedat[256];
1738 Char_t projhist[256];
1740 if(fPadUsedRoc==1) { sprintf(projhist,"ProjectionOROC"); }
1741 if(fPadUsedRoc==0) { sprintf(projhist,"ProjectionIROC"); }
1743 sprintf(filenamedat, "Channel_Run%05i_EventID_%i_Pad_%i_Row_%i.dat" ,fRunId,fEventNumber,pad,row);
1744 sprintf(filenameroot,"Channel_Run%05i_EventID_%i_Pad_%i_Row_%i.root" ,fRunId,fEventNumber,pad,row);
1747 if((hpr=(TH1D*)gROOT->Get(projhist)))
1750 TFile f(filenameroot,"recreate");
1755 ofstream datout(filenamedat,ios::out);
1756 datout <<"Timebin \t ADC value " << endl;
1757 for(Int_t i = 1; i <GetTimeBins(); i++)
1759 datout << i << " \t \t " << fPad[channel][i] << endl;
1765 AliWarning("No projection histo found ");
1769 //__________________________________________________________________
1770 void AliTPCMonitor::ExecTransform()
1773 // Make Fast Fourier Transformation for active pad
1774 // fft is only performed for a data sample of size 2^n
1775 // reduce window according to largest power of 2 which is smaller than the viewing range
1777 Char_t namecanv[256];
1778 Char_t namecanv2[256];
1779 Char_t projhist[256];
1780 Char_t namehtrimag[256];
1781 Char_t namehtrreal[256];
1782 Char_t namehtrmag[256];
1784 if(fPadUsedRoc==1) { sprintf(namecanv,"coroc_ch_trans") ; sprintf(namecanv2,"coroc_ch_trans2") ; sprintf(projhist,"ProjectionOROC"); }
1785 if(fPadUsedRoc==0) { sprintf(namecanv,"ciroc_ch_trans") ; sprintf(namecanv2,"ciroc_ch_trans2") ; sprintf(projhist,"ProjectionIROC"); }
1789 if((TH1D*)gROOT->Get(projhist)==0){AliWarning("Proj histo does not exist \n Move mouse over 2d histo choose channel \n and drag mouse form histo again!"); return ;}
1790 else hproj = (TH1D*)gROOT->Get(projhist) ;
1793 if(fPadUsedRoc==1) { sprintf(namehtrimag,"htransimagfreq_oroc"); sprintf(namehtrreal,"htransrealfreq_oroc"); sprintf(namehtrmag,"htransmagfreq_oroc"); }
1794 else { sprintf(namehtrimag,"htransimagfreq_iroc"); sprintf(namehtrreal,"htransrealfreq_iroc"); sprintf(namehtrmag,"htransmagfreq_iroc"); }
1796 if( gROOT->Get(namehtrimag)) delete gROOT->Get(namehtrimag);
1797 if( gROOT->Get(namehtrreal)) delete gROOT->Get(namehtrreal);
1798 if( gROOT->Get(namehtrmag)) delete gROOT->Get(namehtrmag);
1800 TCanvas *ctrans = 0;
1801 if(!(ctrans = (TCanvas*)gROOT->GetListOfCanvases()->FindObject(namecanv)))
1803 ctrans = CreateCanvas(namecanv);
1804 ctrans->Divide(1,2);
1806 TCanvas *ctrans2 = 0;
1807 if(!(ctrans2 = (TCanvas*)gROOT->GetListOfCanvases()->FindObject(namecanv2)))
1809 ctrans2 = CreateCanvas(namecanv2);
1810 // ctrans2->Divide(1,2);
1813 Int_t binfirst = hproj->GetXaxis()->GetFirst();
1814 Int_t binlast = hproj->GetXaxis()->GetLast();
1815 Int_t bins = binlast -binfirst +1;
1818 for(Int_t pot = 0; pot<=10 ; pot++)
1820 Int_t comp = (Int_t)TMath::Power(2,pot);
1821 if(bins>=comp)power = pot;
1824 bins = (Int_t)TMath::Power(2,power);
1826 // sampling frequency ;
1827 Double_t deltat = 1.0/(Float_t)GetSamplingFrequency();
1830 TH1D* htransrealfreq = new TH1D(namehtrreal,namehtrreal,10000,-1/(2*deltat),1/(2*deltat));
1831 TH1D* htransimagfreq = new TH1D(namehtrimag,namehtrimag,10000,-1/(2*deltat),1/(2*deltat));
1832 TH1D* htransmag = new TH1D(namehtrmag,namehtrmag,10000,-1/(2*deltat),1/(2*deltat));
1834 Char_t titlereal[256];
1835 Char_t titleimag[256];
1836 Char_t titlemag[256];
1837 if(fPadUsedRoc==1) { sprintf(titlereal,"OROC DFT real part"); sprintf(titleimag,"OROC DFT imag part"); sprintf(titlemag,"OROC DFT magnitude"); }
1838 else { sprintf(titlereal,"IROC DFT real part"); sprintf(titleimag,"IROC DFT imag part"); sprintf(titlemag,"IROC DFT magnitude"); }
1840 htransrealfreq->SetTitle(titlereal); htransrealfreq->SetXTitle("f/hz"); htransrealfreq->SetYTitle("z_{real}(f)");
1841 htransimagfreq->SetTitle(titleimag); htransimagfreq->SetXTitle("f/hz"); htransimagfreq->SetYTitle("z_{imag}(f)");
1842 htransmag->SetTitle(titlemag); htransmag->SetXTitle("f/hz"); htransmag->SetYTitle("mag(f)");
1844 // create complex packed data array
1845 const Int_t kdatasiz = 2*bins;
1846 Double_t* data = new Double_t[kdatasiz];
1847 for(Int_t i=0;i<2*bins;i++) { data[i] = 0.0;}
1848 for(Int_t i=0;i<bins;i++) { data[2*i] = (Double_t)hproj->GetBinContent(binfirst+i); }
1850 // make fourier transformation
1851 AliTPCMonitorFFT* four = new AliTPCMonitorFFT();
1852 four->ComplexRadix2ForwardWrap(data,1,bins);
1854 // write output and fill histos forward
1855 Double_t freq = 0.0;
1856 for(Int_t i=0;i<2*bins;i++)
1860 if(i<(bins/2)) { freq = i/(bins*deltat) ; }
1861 else { freq = -1*((bins-i)/(bins*deltat)); }
1862 htransrealfreq->Fill( freq,data[2*i] );
1863 htransimagfreq->Fill( freq,data[2*i+1]);
1864 htransmag->Fill( freq, TMath::Sqrt(data[2*i]*data[2*i]+data[2*i+1]*data[2*i+1]) );
1869 htransrealfreq->Draw();
1871 htransimagfreq->Draw();
1880 //__________________________________________________________________
1881 void AliTPCMonitor::ShowSel(Int_t* compval)
1884 // Show only selected components
1885 // First restore original histogram from clone
1886 // Than remove all not matching pads form histos
1888 Int_t connector = 0;
1890 Int_t altrochip = 0;
1891 Int_t feclocbran = 0;
1898 Float_t maxiroc = fHistIROCClone->GetMaximum();
1899 Float_t maxoroc = fHistOROCClone->GetMaximum();
1902 // restore original histos
1903 for(Int_t row = 0; row<fkNRowsIroc; row++)
1905 for(Int_t pad = 0; pad<fkNPadsIroc; pad++)
1907 index = (Int_t)fHistIROCIndex->GetCellContent(row+1,pad+1);
1908 if(index==-1)continue;
1909 else fHistIROC->SetCellContent(row+1,pad+1,fHistIROCClone->GetCellContent(row+1,pad+1));
1912 for(Int_t row = 0; row<fkNRowsOroc; row++)
1914 for(Int_t pad = 0; pad<fkNPadsOroc; pad++)
1916 index = (Int_t)fHistOROCIndex->GetCellContent(row+1,pad+1);
1917 if(index==-1)continue;
1918 else fHistOROC->SetCellContent(row+1,pad+1,fHistOROCClone->GetCellContent(row+1,pad+1));
1923 // remove not matching entries from fHistIROC/fHistOROC
1926 TH2S* fHistIndex =0;
1930 for(Int_t row = 0; row< (fkNRowsIroc + fkNRowsOroc); row++)
1932 if(row<fkNRowsIroc) { fHist=fHistIROC ; fHistIndex = fHistIROCIndex; npads = fkNPadsIroc; subrows =0 ;}
1933 else { fHist=fHistOROC ; fHistIndex = fHistOROCIndex; npads = fkNPadsOroc; subrows =fkNRowsIroc;}
1935 for(Int_t pad = 0; pad<npads; pad++)
1937 index = (Int_t)fHistIndex->GetCellContent(row -subrows +1,pad+1);
1938 if(index==-1) continue ;
1939 hwadd = (Int_t)fHistChannelTime->GetCellContent(index,0);
1942 fecnr = fMapHand->GetFECfromHw(hwadd);
1943 if(compval[0]!=-1 && fecnr!=compval[0]) { fHist->SetCellContent(row-subrows+1,pad+1,0); continue; }
1946 rcuget = (hwadd & fgkHwMaskRCU)>> 12;
1947 if(compval[1]!=-1 && rcuget!=compval[1]) { fHist->SetCellContent(row-subrows+1,pad+1,0); continue; }
1950 branch = fMapHand->U2fGetBranch(fecnr) ;
1951 if(compval[2]!=-1 && branch!=compval[2]) { fHist->SetCellContent(row-subrows+1,pad+1,0); continue; }
1954 feclocbran= fMapHand->U2fGetFECinBranch(fecnr) ;
1955 if(compval[3]!=-1 && feclocbran!=compval[3]) { fHist->SetCellContent(row-subrows+1,pad+1,0); continue; }
1958 connector = fMapHand->GetFECconnector(hwadd);
1959 if(compval[4]!=-1 && connector!=compval[4]) { fHist->SetCellContent(row-subrows+1,pad+1,0); continue; }
1962 altrochip = fMapHand->GetAltro(hwadd);
1963 if(compval[5]!=-1 && altrochip!=compval[5]) { fHist->SetCellContent(row-subrows+1,pad+1,0); continue; }
1970 if(gROOT->GetListOfCanvases()->FindObject("ciroc"))
1972 c1 = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("ciroc");
1974 fHistIROC->Draw("COLZ");
1975 fHistIROC->SetMaximum(maxiroc);
1976 fHistIROC->SetMinimum(0.0);
1979 if(gROOT->GetListOfCanvases()->FindObject("coroc"))
1981 c2 = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("coroc");
1983 fHistOROC->Draw("COLZ");
1984 fHistOROC->SetMaximum(maxoroc);
1985 fHistOROC->SetMinimum(0.0);
1991 //__________________________________________________________________
1992 void AliTPCMonitor::ResizeCanv()
1994 // Resize canvases and delete some of them
1997 sprintf(carry1,".x %s/TPC/AliTPCMonitorExec.C(1)",gSystem->Getenv("ALICE_ROOT"));
1999 sprintf(carry3,".x %s/TPC/AliTPCMonitorExec.C(2)",gSystem->Getenv("ALICE_ROOT"));
2000 if(fVerb) cout << " canv 1 " << endl;
2002 if(gROOT->GetListOfCanvases()->FindObject( "coroc_ch")) { delete gROOT->GetListOfCanvases()->FindObject("coroc_ch") ; }
2003 if(gROOT->GetListOfCanvases()->FindObject( "ciroc_ch")) { delete gROOT->GetListOfCanvases()->FindObject("ciroc_ch") ; }
2005 // for 2dim plots delete create and draw again
2006 if(gROOT->GetListOfCanvases()->FindObject("ciroc"))
2008 delete gROOT->GetListOfCanvases()->FindObject("ciroc");
2009 TCanvas* ciroc = CreateCanvas("ciroc");
2011 fHistIROC->Draw("COLZ");
2012 ciroc->AddExec("pad",carry1);
2013 ciroc->AddExec("row",carry3);
2017 // for 2dim plots delete create and draw again
2018 if(gROOT->GetListOfCanvases()->FindObject("coroc"))
2020 delete gROOT->GetListOfCanvases()->FindObject("coroc");
2021 TCanvas* coroc = CreateCanvas("coroc");
2023 fHistOROC->Draw("COLZ");
2025 coroc->AddExec("pad",carry1);
2026 coroc->AddExec("row",carry3);
2031 if(gROOT->GetListOfCanvases()->FindObject( "cbasemean")) { delete gROOT->GetListOfCanvases()->FindObject("cbasemean"); }
2032 if(gROOT->GetListOfCanvases()->FindObject( "cbase")) { delete gROOT->GetListOfCanvases()->FindObject("cbase");}
2033 if(gROOT->GetListOfCanvases()->FindObject( "cbaserms")) { delete gROOT->GetListOfCanvases()->FindObject("cbaserms"); }
2034 if(gROOT->GetListOfCanvases()->FindObject( "cmax")) { delete gROOT->GetListOfCanvases()->FindObject("cmax"); }
2035 if(gROOT->GetListOfCanvases()->FindObject( "csum")) { delete gROOT->GetListOfCanvases()->FindObject("csum"); }
2036 if(gROOT->GetListOfCanvases()->FindObject( "ciroc_ch_trans")) { delete gROOT->GetListOfCanvases()->FindObject("ciroc_ch_trans");}
2037 if(gROOT->GetListOfCanvases()->FindObject( "coroc_ch_trans")) { delete gROOT->GetListOfCanvases()->FindObject("coroc_ch_trans");}
2038 if(gROOT->GetListOfCanvases()->FindObject( "crowtime")) { delete gROOT->GetListOfCanvases()->FindObject("crowtime"); }
2039 if(gROOT->GetListOfCanvases()->FindObject( "crowmax")) { delete gROOT->GetListOfCanvases()->FindObject("crowmax"); }
2040 if(gROOT->GetListOfCanvases()->FindObject( "cxmax")) { delete gROOT->GetListOfCanvases()->FindObject("cxmax"); }
2041 if(gROOT->GetListOfCanvases()->FindObject( "crmsoroc")) { delete gROOT->GetListOfCanvases()->FindObject("crmsoroc"); fExecPadOrocRms = 0; }
2042 if(gROOT->GetListOfCanvases()->FindObject( "crmsiroc")) { delete gROOT->GetListOfCanvases()->FindObject("crmsiroc"); fExecPadIrocRms = 0; }
2043 if(gROOT->GetListOfCanvases()->FindObject( "crowmax")) { delete gROOT->GetListOfCanvases()->FindObject("crowmax"); }
2044 if(gROOT->GetListOfCanvases()->FindObject( "crowmax")) { delete gROOT->GetListOfCanvases()->FindObject("crowmax"); }
2051 //__________________________________________________________________
2052 Int_t AliTPCMonitor::ExecProcess()
2054 // Executable for global Histogram
2055 // Will be called from /TPC/AliTPCMonitorExec.C(3)
2056 // Call ProcessEvent for same event and sector pointed at
2061 Int_t event = gPad->GetEvent();
2062 if(event != 61) return -1;
2064 TObject *select = gPad->GetSelected();
2065 if(!select) return -1;
2066 if(!select->InheritsFrom("TH2")) {gPad->SetUniqueID(0); return -1; }
2067 if( strcmp(select->GetName(),"hglobal" )==0 || ( strcmp(select->GetName(),"SIDE A" )==0) ) side = 0;
2068 else if( strcmp(select->GetName(),"hglobal2")==0 || ( strcmp(select->GetName(),"SIDE C" )==0) ) side = 1;
2071 Int_t px = gPad->GetEventX();
2072 Int_t py = gPad->GetEventY();
2073 Float_t upy = gPad->AbsPixeltoY(py);
2074 Float_t upx = gPad->AbsPixeltoX(px);
2075 Float_t y = gPad->PadtoY(upy);
2076 Float_t x = gPad->PadtoX(upx);
2078 Int_t testy = ((TH2*)select)->GetYaxis()->FindBin(y);
2079 Int_t testx = ((TH2*)select)->GetXaxis()->FindBin(x);
2080 if(((TH2*)select)->GetCellContent(testx,testy)==0) return -1 ;
2082 Float_t alpha = 0.0;
2083 if(x>0.0 && y > 0.0) alpha = TMath::Abs(TMath::ATan(TMath::Abs(x/y)));
2084 if(x>0.0 && y < 0.0) alpha = TMath::Abs(TMath::ATan(TMath::Abs(y/x)));
2085 if(x<0.0 && y < 0.0) alpha = TMath::Abs(TMath::ATan(TMath::Abs(x/y)));
2086 if(x<0.0 && y > 0.0) alpha = TMath::Abs(TMath::ATan(TMath::Abs(y/x)));
2088 if(x>0.0 && y < 0.0) alpha += ( TMath::Pi()/2);
2089 if(x<0.0 && y < 0.0) alpha += ( TMath::Pi());
2090 if(x<0.0 && y > 0.0) alpha += (1.5*TMath::Pi());
2092 sector = (Int_t)(alpha/(2*TMath::Pi()/18.0));
2093 if(alpha> (sector+0.5)*(2*TMath::Pi()/18.0)) sector+=1;
2095 if(sector==18 && side ==0 ) {
2096 AliWarning("There was a wromg assignment of sector 0 with sector 18. Check sectors");
2100 sector = (18-sector +4)%18;
2101 SetLastSector(sector+ side*18);
2102 SetProcNextEvent(0);
2104 if(fVerb) cout << "AliTPCMonitor::ExecProcess() next side " << side << " next sector " << sector << endl;
2106 return (Int_t)ProcessEvent();
2110 //__________________________________________________________________
2111 Int_t AliTPCMonitor::GetRCUPatch(Int_t runid, Int_t eqid) const
2114 // Return RCU patch index for given equipment id eqid
2117 if ( eqid<768 || eqid>983 ) return 0; //no TPC eqid
2120 if(eqid>=1000) return 0;
2121 patch = fMapEqidsRcu[eqid] ;
2125 if(eqid==408) {patch = 13*6+4 +0; }
2126 if(eqid==409) {patch = 13*6+5 +0; }
2127 if(eqid==509) {patch = 13*6+0 +0; }
2128 if(eqid==512) {patch = 13*6+3 +0; }
2129 if(eqid==513) {patch = 13*6+1 +0; }
2130 if(eqid==517) {patch = 13*6+2 +0; }
2132 if(eqid==404) {patch = 4*6+5 +0; }
2133 if(eqid==504) {patch = 4*6+4 +0; }
2134 if(eqid==407) {patch = 4*6+3 +0; }
2135 if(eqid==503) {patch = 4*6+2 +0; }
2136 if(eqid==508) {patch = 4*6+1 +0; }
2137 if(eqid==506) {patch = 4*6+0 +0; }
2142 //__________________________________________________________________
2143 void AliTPCMonitor::DumpHeader(AliRawReader * reader) const
2145 // Dump Event header for format
2147 cout << "EventHeader : fReader->GetEquipmentSize() :" << reader->GetEquipmentSize() << endl;
2148 cout << "EventHeader : fReader->GetType() :" << reader->GetType() << endl;
2149 cout << "EventHeader : fReader->GetRunNumber() :" << reader->GetRunNumber() << endl;
2150 cout << "EventHeader : fReader->GetEventId() :" << *(reader->GetEventId()) << endl;
2151 cout << "EventHeader : fReader->GetLDCId() :" << reader->GetLDCId() << endl;
2152 cout << "EventHeader : fReader->GetGDCId() :" << reader->GetGDCId() << endl;
2156 //__________________________________________________________________
2157 Double_t AliTPCMonitor::Gamma4(Double_t* x, Double_t* par) {
2159 // Gamma4 function used to fit signals
2160 // Defined in sections: diverging branch set to 0
2164 val = par[0]*exp(4.0)* pow((x[0]-par[1])/par[2],4)*exp(-4.0*(x[0]-par[1])/par[2])+ par[3];
2170 //__________________________________________________________________
2171 TCanvas* AliTPCMonitor::CreateCanvas(const Char_t* name)
2177 Int_t xoffset = GetCanvasXOffset();
2178 Int_t xsize = GetCanvasXSize();
2179 Int_t ysize = GetCanvasYSize();
2180 Int_t xspace = GetCanvasXSpace();
2181 Int_t yspace = GetCanvasYSpace();
2183 // ROC 2dim max distribution
2184 if( strcmp(name,"coroc" )==0) { canv = new TCanvas("coroc" ,"coroc" , -1+xoffset,(Int_t)(yspace+0.5*ysize) ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2185 else if(strcmp(name,"ciroc" )==0) { canv = new TCanvas("ciroc" ,"ciroc" , -1+xoffset, 0 ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2186 // ROC 2dim rms distribution
2187 else if(strcmp(name,"crmsoroc" )==0) { canv = new TCanvas("crmsoroc" ,"crmsoroc" , -1+xoffset,(Int_t)(yspace+0.5*ysize) ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2188 else if(strcmp(name,"crmsiroc" )==0) { canv = new TCanvas("crmsiroc" ,"crmsiroc" , -1+xoffset, 0 ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2189 // Global ADC max Histos
2190 else if(strcmp(name,"SIDE C all" )==0) { canv = new TCanvas("SIDE C all" ,"SIDE C all" , (Int_t)(3*xspace+ xoffset),(Int_t)(yspace+0.5*ysize) ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2191 else if(strcmp(name,"SIDE A all" )==0) { canv = new TCanvas("SIDE A all" ,"SIDE A all" , (Int_t)(3*xspace+ xoffset), 0 ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2192 // 1 dim max sum basekine distribution
2193 else if(strcmp(name,"cmax" )==0) { canv = new TCanvas("cmax" ,"cmax" , -1+xoffset, 3*yspace ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv; }
2194 else if(strcmp(name,"csum" )==0) { canv = new TCanvas("csum" ,"csum" , xspace+xoffset, 3*yspace ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv; }
2195 else if(strcmp(name,"cbasemean" )==0) { canv = new TCanvas("cbasemean" ,"cbasemean" , 2*xspace+xoffset, 3*yspace ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv; }
2196 else if(strcmp(name,"cbaserms" )==0) { canv = new TCanvas("cbaserms" ,"cbaserms" , 3*xspace+xoffset, 3*yspace ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv; }
2197 // Projections of single channel
2198 else if(strcmp(name,"coroc_ch" )==0) { canv = new TCanvas("coroc_ch" ,"coroc_ch" , (Int_t)(1.5*xspace+xoffset),(Int_t)(yspace+0.5*ysize),(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2199 else if(strcmp(name,"ciroc_ch" )==0) { canv = new TCanvas("ciroc_ch" ,"ciroc_ch" , (Int_t)(1.5*xspace+xoffset), 0 ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2200 // FFT for single channel
2201 else if(strcmp(name,"coroc_ch_trans")==0) { canv = new TCanvas("coroc_ch_trans","coroc_ch_trans",(Int_t)(3.0*xspace+xoffset),(Int_t)(yspace+0.5*ysize),(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2202 else if(strcmp(name,"ciroc_ch_trans")==0) { canv = new TCanvas("ciroc_ch_trans","ciroc_ch_trans",(Int_t)(3.0*xspace+xoffset), 0 ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2203 else if(strcmp(name,"coroc_ch_trans2")==0) { canv = new TCanvas("coroc_ch_trans2","coroc_ch_trans2",(Int_t)(3.0*xspace+xoffset),(Int_t)(yspace+0.5*ysize),(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2204 else if(strcmp(name,"ciroc_ch_trans2")==0) { canv = new TCanvas("ciroc_ch_trans2","ciroc_ch_trans2",(Int_t)(3.0*xspace+xoffset), 0 ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2205 // row profile histograms
2206 else if(strcmp(name,"crowtime" )==0) { canv = new TCanvas("crowtime" ,"crowtime" , 1*xspace+xoffset, 2*yspace +ysize ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv; }
2207 else if(strcmp(name,"crowmax" )==0) { canv = new TCanvas("crowmax" ,"crowmax" , 2*xspace+xoffset, 2*yspace +ysize ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv; }
2208 else if(strcmp(name,"cxmax" )==0) { canv = new TCanvas("cxmax" ,"cxmax" , 3*xspace+xoffset, 2*yspace +ysize ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv; }
2209 else { cout << " Warning Canvas name unknown " << endl; return 0 ; }
2212 //__________________________________________________________________
2213 void AliTPCMonitor::WriteHistos()
2215 // Writes all available histograms to a file in current directory
2216 // File name will be specified by : sector, side, runid and eventnumber
2218 if(GetEventProcessed())
2220 AliInfo("Write histos to file");
2222 sprintf(name,"SIDE_%i_SECTOR_%02i_RUN_%05i_EventID_%06i.root",(GetLastSector()/18),(GetLastSector()%18),fRunId,fEventNumber);
2223 TFile* f = new TFile(name,"recreate");
2224 for(Int_t i =0; i<fHistList->GetEntries(); i++)
2226 if(((TH1*)fHistList->At(i))!=0)
2228 ((TH1*)fHistList->At(i))->Write();
2236 AliError("No Event Processed : Chose Format , File and push 'Next Event' ");
2241 //__________________________________________________________________
2242 TH1* AliTPCMonitor::GetHisto(char* histname)
2245 // Returns histogram specified by histname
2246 // check available names for histos in CreateHistos()
2249 if((TH1*)fHistList->FindObject(histname))
2251 hist = (TH1*)fHistList->FindObject(histname);
2255 cout << " AliTPCMonitor::GetHisto :: Can not find histo with name " << histname << endl;