]>
Commit | Line | Data |
---|---|---|
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 | // $Id$ | |
17 | ||
18 | /// \ingroup macros | |
19 | /// \file MUONRawStreamTracker.C | |
20 | /// \brief Macro for reading tracker raw data | |
21 | /// | |
22 | /// \author Ch. Finck, Subatech Febuary | |
23 | /// | |
24 | /// Added example routines to show how to use the interface of the high | |
25 | /// performance decoder AliMUONRawStreamTrackerHP. | |
26 | /// by Artur Szostak <artursz@iafrica.com> | |
27 | /// | |
28 | /// This macro is interfaced with AliRawReader for RAW | |
29 | /// | |
30 | /// There are 2 ways of reading the data: | |
31 | /// - one where each intermediate structure (block, dsp, buspatch) is looped over | |
32 | /// - and one, using an iterator, where we're directly accessing the pad informations | |
33 | /// (charge). | |
34 | /// | |
35 | ||
36 | ||
37 | #if !defined(__CINT__) || defined(__MAKECINT__) | |
38 | ||
39 | // RAW includes | |
40 | #include "AliRawReader.h" | |
41 | ||
42 | // MUON includes | |
43 | #include "AliMUONRawStreamTrackerHP.h" | |
44 | #include "TStopwatch.h" | |
45 | ||
46 | #endif | |
47 | ||
48 | void MUONRawStreamTrackerExpert(TString fileName = "./", Int_t maxEvent = 1000, | |
49 | Int_t minDDL = 0, Int_t maxDDL = 19) | |
50 | { | |
51 | /// This routine shows how to use the decoder's expert interface. | |
52 | ||
53 | TStopwatch timer; | |
54 | timer.Start(kTRUE); | |
55 | ||
56 | AliRawReader* rawReader = AliRawReader::Create(fileName.Data()); | |
57 | ||
58 | // raw stream | |
59 | AliMUONRawStreamTrackerHP rawStream(rawReader); | |
60 | ||
61 | // light weight interfaces to headers | |
62 | const AliMUONRawStreamTrackerHP::AliBlockHeader* blkHeader = 0x0; | |
63 | const AliMUONRawStreamTrackerHP::AliDspHeader* dspHeader = 0x0; | |
64 | const AliMUONRawStreamTrackerHP::AliBusPatch* busStruct = 0x0; | |
65 | ||
66 | // Loop over events | |
67 | Int_t iEvent = 0; | |
68 | Int_t dataSize; | |
69 | ||
70 | while (rawReader->NextEvent()) { | |
71 | ||
72 | if (iEvent == maxEvent) | |
73 | break; | |
74 | ||
75 | printf("Event %d\n",iEvent++); | |
76 | ||
77 | // read DDL while < 20 DDL | |
78 | while(rawStream.NextDDL()) { | |
79 | ||
80 | if (rawStream.GetDDL() < minDDL || rawStream.GetDDL() > maxDDL) | |
81 | continue; | |
82 | ||
83 | printf("\niDDL %d\n", rawStream.GetDDL()); | |
84 | ||
85 | // loop over block structure | |
86 | Int_t nBlock = rawStream.GetBlockCount(); | |
87 | for(Int_t iBlock = 0; iBlock < nBlock ;iBlock++){ | |
88 | ||
89 | blkHeader = rawStream.GetBlockHeader(iBlock); | |
90 | printf("Block %d Total length %d\n",iBlock,blkHeader->GetTotalLength()); | |
91 | ||
92 | // loop over DSP structure | |
93 | Int_t nDsp = rawStream.GetDspCount(iBlock); | |
94 | for(Int_t iDsp = 0; iDsp < nDsp ;iDsp++){ //DSP loop | |
95 | ||
96 | dspHeader = blkHeader->GetDspHeader(iDsp); | |
97 | printf("Dsp %d length %d error word %d\n",iDsp,dspHeader->GetTotalLength(), dspHeader->GetErrorWord()); | |
98 | ||
99 | // loop over BusPatch structure | |
100 | Int_t nBusPatch = rawStream.GetBusPatchCount(iBlock, iDsp); | |
101 | for(Int_t iBusPatch = 0; iBusPatch < nBusPatch; iBusPatch++) { | |
102 | ||
103 | busStruct = dspHeader->GetBusPatch(iBusPatch); | |
104 | ||
105 | // loop over data | |
106 | dataSize = busStruct->GetLength(); | |
107 | for (Int_t iData = 0; iData < dataSize; iData++) { | |
108 | ||
109 | Int_t manuId = busStruct->GetManuId(iData); | |
110 | Int_t channelId = busStruct->GetChannelId(iData); | |
111 | Int_t charge = busStruct->GetCharge(iData); | |
112 | printf("buspatch %5d manuI %4d channel %3d charge %4d\n", | |
113 | busStruct->GetBusPatchId(), | |
114 | manuId, | |
115 | channelId, charge); | |
116 | } // iData | |
117 | } // iBusPatch | |
118 | } // iDsp | |
119 | } // iBlock | |
120 | } // NextDDL | |
121 | }// NextEvent | |
122 | ||
123 | delete rawReader; | |
124 | timer.Print(); | |
125 | } | |
126 | ||
127 | ||
128 | void MUONRawStreamTrackerExpert2(TString fileName = "./", Int_t maxEvent = 1000, | |
129 | Int_t minDDL = 0, Int_t maxDDL = 19) | |
130 | { | |
131 | /// This routine shows an alternate way to iterate over the DDL structures | |
132 | /// compared to MUONRawStreamTrackerExpert(). | |
133 | ||
134 | TStopwatch timer; | |
135 | timer.Start(kTRUE); | |
136 | ||
137 | AliRawReader* rawReader = AliRawReader::Create(fileName.Data()); | |
138 | ||
139 | // raw stream | |
140 | AliMUONRawStreamTrackerHP rawStream(rawReader); | |
141 | ||
142 | // light weight interfaces to headers | |
143 | const AliMUONRawStreamTrackerHP::AliBlockHeader* blkHeader = 0x0; | |
144 | const AliMUONRawStreamTrackerHP::AliDspHeader* dspHeader = 0x0; | |
145 | const AliMUONRawStreamTrackerHP::AliBusPatch* busStruct = 0x0; | |
146 | ||
147 | // Loop over events | |
148 | Int_t iEvent = 0; | |
149 | Int_t dataSize; | |
150 | ||
151 | while (rawReader->NextEvent()) { | |
152 | ||
153 | if (iEvent == maxEvent) | |
154 | break; | |
155 | ||
156 | printf("Event %d\n",iEvent++); | |
157 | ||
158 | // read DDL while < 20 DDL | |
159 | while(rawStream.NextDDL()) { | |
160 | ||
161 | if (rawStream.GetDDL() < minDDL || rawStream.GetDDL() > maxDDL) | |
162 | continue; | |
163 | ||
164 | printf("\niDDL %d\n", rawStream.GetDDL()); | |
165 | ||
166 | // loop over block structure | |
167 | Int_t nBlock = rawStream.GetBlockCount(); | |
168 | for(Int_t iBlock = 0; iBlock < nBlock ;iBlock++){ | |
169 | ||
170 | blkHeader = rawStream.GetBlockHeader(iBlock); | |
171 | printf("Block %d Total length %d\n",iBlock,blkHeader->GetTotalLength()); | |
172 | ||
173 | // loop over DSP structure | |
174 | Int_t nDsp = rawStream.GetDspCount(iBlock); | |
175 | for(Int_t iDsp = 0; iDsp < nDsp ;iDsp++){ //DSP loop | |
176 | ||
177 | dspHeader = rawStream.GetDspHeader(iBlock, iDsp); | |
178 | printf("Dsp %d length %d error word %d\n",iDsp,dspHeader->GetTotalLength(), dspHeader->GetErrorWord()); | |
179 | ||
180 | // loop over BusPatch structure | |
181 | Int_t nBusPatch = rawStream.GetBusPatchCount(iBlock, iDsp); | |
182 | for(Int_t iBusPatch = 0; iBusPatch < nBusPatch; iBusPatch++) { | |
183 | ||
184 | busStruct = rawStream.GetBusPatch(iBlock, iDsp, iBusPatch); | |
185 | ||
186 | // loop over data | |
187 | dataSize = busStruct->GetLength(); | |
188 | for (Int_t iData = 0; iData < dataSize; iData++) { | |
189 | ||
190 | Int_t manuId = busStruct->GetManuId(iData); | |
191 | Int_t channelId = busStruct->GetChannelId(iData); | |
192 | Int_t charge = busStruct->GetCharge(iData); | |
193 | printf("buspatch %5d manuI %4d channel %3d charge %4d\n", | |
194 | busStruct->GetBusPatchId(), | |
195 | manuId, | |
196 | channelId, charge); | |
197 | } // iData | |
198 | } // iBusPatch | |
199 | } // iDsp | |
200 | } // iBlock | |
201 | } // NextDDL | |
202 | }// NextEvent | |
203 | ||
204 | delete rawReader; | |
205 | timer.Print(); | |
206 | } | |
207 | ||
208 | ||
209 | void MUONRawStreamTrackerExpert3(TString fileName = "./", Int_t maxEvent = 1000, | |
210 | Int_t minDDL = 0, Int_t maxDDL = 19) | |
211 | { | |
212 | /// This routine shows yet another alternate way to iterate over the DDL | |
213 | /// structures compared to MUONRawStreamTrackerExpert(). | |
214 | ||
215 | TStopwatch timer; | |
216 | timer.Start(kTRUE); | |
217 | ||
218 | AliRawReader* rawReader = AliRawReader::Create(fileName.Data()); | |
219 | ||
220 | // raw stream | |
221 | AliMUONRawStreamTrackerHP rawStream(rawReader); | |
222 | ||
223 | // light weight interfaces to headers | |
224 | const AliMUONRawStreamTrackerHP::AliBlockHeader* blkHeader = 0x0; | |
225 | const AliMUONRawStreamTrackerHP::AliDspHeader* dspHeader = 0x0; | |
226 | const AliMUONRawStreamTrackerHP::AliBusPatch* busStruct = 0x0; | |
227 | ||
228 | // Loop over events | |
229 | Int_t iEvent = 0; | |
230 | Int_t dataSize; | |
231 | ||
232 | while (rawReader->NextEvent()) { | |
233 | ||
234 | if (iEvent == maxEvent) | |
235 | break; | |
236 | ||
237 | printf("Event %d\n",iEvent++); | |
238 | ||
239 | // read DDL while < 20 DDL | |
240 | while(rawStream.NextDDL()) { | |
241 | ||
242 | if (rawStream.GetDDL() < minDDL || rawStream.GetDDL() > maxDDL) | |
243 | continue; | |
244 | ||
245 | printf("\niDDL %d\n", rawStream.GetDDL()); | |
246 | ||
247 | // loop over block structure | |
248 | Int_t iBlock = 0; | |
249 | blkHeader = rawStream.GetFirstBlockHeader(); | |
250 | while (blkHeader != NULL) | |
251 | { | |
252 | printf("Block %d Total length %d\n",iBlock,blkHeader->GetTotalLength()); | |
253 | ||
254 | // loop over DSP structure | |
255 | Int_t iDsp = 0; | |
256 | dspHeader = blkHeader->GetFirstDspHeader(); | |
257 | while (dspHeader != NULL) | |
258 | { | |
259 | printf("Dsp %d length %d error word %d\n",iDsp,dspHeader->GetTotalLength(), dspHeader->GetErrorWord()); | |
260 | ||
261 | // loop over BusPatch structure | |
262 | Int_t iBusPatch = 0; | |
263 | busStruct = dspHeader->GetFirstBusPatch(); | |
264 | while (busStruct != NULL) | |
265 | { | |
266 | // loop over data | |
267 | dataSize = busStruct->GetLength(); | |
268 | for (Int_t iData = 0; iData < dataSize; iData++) { | |
269 | ||
270 | Int_t manuId = busStruct->GetManuId(iData); | |
271 | Int_t channelId = busStruct->GetChannelId(iData); | |
272 | Int_t charge = busStruct->GetCharge(iData); | |
273 | printf("buspatch %5d manuI %4d channel %3d charge %4d\n", | |
274 | busStruct->GetBusPatchId(), | |
275 | manuId, | |
276 | channelId, charge); | |
277 | } // iData | |
278 | busStruct = busStruct->Next(); | |
279 | iBusPatch++; | |
280 | } // iBusPatch | |
281 | dspHeader = dspHeader->Next(); | |
282 | iDsp++; | |
283 | } // iDsp | |
284 | blkHeader = blkHeader->Next(); | |
285 | iBlock++; | |
286 | } // iBlock | |
287 | } // NextDDL | |
288 | }// NextEvent | |
289 | ||
290 | delete rawReader; | |
291 | timer.Print(); | |
292 | } | |
293 | ||
294 | ||
295 | void MUONRawStreamTrackerSimple(TString fileName = "./", Int_t maxEvent = 1000) | |
296 | { | |
297 | /// This routine shows how to use the high performance decoder's simple interface. | |
298 | ||
299 | TStopwatch timer; | |
300 | timer.Start(kTRUE); | |
301 | ||
302 | AliRawReader* rawReader = AliRawReader::Create(fileName.Data()); | |
303 | ||
304 | // raw stream | |
305 | AliMUONRawStreamTrackerHP rawStream(rawReader); | |
306 | ||
307 | // Loop over events | |
308 | Int_t iEvent = 0; | |
309 | ||
310 | while (rawReader->NextEvent()) { | |
311 | ||
312 | if (iEvent == maxEvent) | |
313 | break; | |
314 | ||
315 | printf("Event %d\n",iEvent++); | |
316 | ||
317 | Int_t busPatch; | |
318 | UShort_t manuId, adc; | |
319 | UChar_t manuChannel; | |
320 | ||
321 | rawStream.First(); | |
322 | ||
323 | while ( rawStream.Next(busPatch,manuId,manuChannel,adc) ) | |
324 | { | |
325 | printf("buspatch %5d manuI %4d channel %3d charge %4d\n", | |
326 | busPatch,manuId,manuChannel, adc); | |
327 | } | |
328 | } | |
329 | ||
330 | delete rawReader; | |
331 | timer.Print(); | |
332 | } | |
333 | ||
334 | ||
335 | void MUONRawStreamTrackerSimple2(TString fileName = "./", Int_t maxEvent = 1000) | |
336 | { | |
337 | /// This routine is an alternative to MUONRawStreamTrackerSimple() which is even faster. | |
338 | ||
339 | TStopwatch timer; | |
340 | timer.Start(kTRUE); | |
341 | ||
342 | AliRawReader* rawReader = AliRawReader::Create(fileName.Data()); | |
343 | ||
344 | // raw stream | |
345 | AliMUONRawStreamTrackerHP rawStream(rawReader); | |
346 | ||
347 | // Loop over events | |
348 | Int_t iEvent = 0; | |
349 | ||
350 | while (rawReader->NextEvent()) { | |
351 | ||
352 | if (iEvent == maxEvent) | |
353 | break; | |
354 | ||
355 | printf("Event %d\n",iEvent++); | |
356 | ||
357 | UShort_t manuId, adc; | |
358 | UChar_t manuChannel; | |
359 | ||
360 | rawStream.First(); | |
361 | const AliMUONRawStreamTrackerHP::AliBusPatch* buspatch = NULL; | |
362 | while ((buspatch = rawStream.Next()) != NULL) | |
363 | { | |
364 | for (UInt_t i = 0; i < buspatch->GetDataCount(); i++) | |
365 | { | |
366 | buspatch->GetData(i, manuId, manuChannel, adc); | |
367 | printf("buspatch %5d manuI %4d channel %3d charge %4d\n", | |
368 | buspatch->GetBusPatchId(), manuId, manuChannel, adc); | |
369 | } | |
370 | } | |
371 | } | |
372 | ||
373 | delete rawReader; | |
374 | timer.Print(); | |
375 | } | |
376 |