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