Resolving all symbols in the library
[u/mrichter/AliRoot.git] / MUON / MUONRawStreamTracker.C
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 #include "AliRawDataErrorLog.h"
46 #include "Riostream.h"
47 #include "AliMUONLogger.h"
48
49 #endif
50
51 void MUONRawStreamTrackerExpert(TString fileName = "./", Int_t maxEvent = 1000,  
52                                 Int_t minDDL = 0, Int_t maxDDL = 19)
53 {
54   /// This routine shows how to use the decoder's expert interface.
55   
56   TStopwatch timer;
57   timer.Start(kTRUE);
58   
59   AliRawReader* rawReader = AliRawReader::Create(fileName.Data());
60   
61   // raw stream
62   AliMUONRawStreamTrackerHP rawStream(rawReader);
63   
64   // light weight interfaces to headers
65   const AliMUONRawStreamTrackerHP::AliBlockHeader*      blkHeader  = 0x0;
66   const AliMUONRawStreamTrackerHP::AliDspHeader*        dspHeader  = 0x0;
67   const AliMUONRawStreamTrackerHP::AliBusPatch*         busStruct  = 0x0;
68   
69   //   Loop over events  
70   Int_t iEvent = 0;
71   Int_t dataSize;
72   
73   while (rawReader->NextEvent()) {
74     
75     if (iEvent == maxEvent)
76       break;
77     
78     printf("Event %d\n",iEvent++);
79     
80     // read DDL while < 20 DDL
81     while(rawStream.NextDDL()) {
82       
83       if (rawStream.GetDDL() < minDDL || rawStream.GetDDL() > maxDDL)
84         continue;
85       
86       printf("\niDDL %d\n", rawStream.GetDDL());
87       
88       // loop over block structure
89       Int_t nBlock = rawStream.GetBlockCount();
90       for(Int_t iBlock = 0; iBlock < nBlock ;iBlock++){
91         
92         blkHeader = rawStream.GetBlockHeader(iBlock);
93         printf("Block %d Total length %d\n",iBlock,blkHeader->GetTotalLength());
94        
95         // loop over DSP structure
96         Int_t nDsp = rawStream.GetDspCount(iBlock);
97         for(Int_t iDsp = 0; iDsp < nDsp ;iDsp++){   //DSP loop
98           
99           dspHeader =  blkHeader->GetDspHeader(iDsp);
100           printf("Dsp %d length %d error word %d\n",iDsp,dspHeader->GetTotalLength(), dspHeader->GetErrorWord());
101           
102           // loop over BusPatch structure
103           Int_t nBusPatch = rawStream.GetBusPatchCount(iBlock, iDsp);
104           for(Int_t iBusPatch = 0; iBusPatch < nBusPatch; iBusPatch++) {  
105             
106             busStruct = dspHeader->GetBusPatch(iBusPatch);
107             
108             // loop over data
109             dataSize = busStruct->GetLength();
110             for (Int_t iData = 0; iData < dataSize; iData++) {
111               
112               Int_t  manuId    = busStruct->GetManuId(iData);
113               Int_t  channelId = busStruct->GetChannelId(iData);
114               Int_t  charge    = busStruct->GetCharge(iData);
115               printf("buspatch %5d manuI %4d channel %3d charge %4d\n", 
116                      busStruct->GetBusPatchId(),
117                      manuId, 
118                      channelId, charge);
119             } // iData
120           } // iBusPatch
121         } // iDsp
122       } // iBlock
123     } // NextDDL
124   }// NextEvent
125   
126   delete rawReader;
127   timer.Print();
128 }
129
130
131 void MUONRawStreamTrackerExpert2(TString fileName = "./", Int_t maxEvent = 1000,  
132                                 Int_t minDDL = 0, Int_t maxDDL = 19)
133 {
134   /// This routine shows an alternate way to iterate over the DDL structures
135   /// compared to MUONRawStreamTrackerExpert().
136   
137   TStopwatch timer;
138   timer.Start(kTRUE);
139   
140   AliRawReader* rawReader = AliRawReader::Create(fileName.Data());
141   
142   // raw stream
143   AliMUONRawStreamTrackerHP rawStream(rawReader);
144   
145   // light weight interfaces to headers
146   const AliMUONRawStreamTrackerHP::AliBlockHeader*      blkHeader  = 0x0;
147   const AliMUONRawStreamTrackerHP::AliDspHeader*        dspHeader  = 0x0;
148   const AliMUONRawStreamTrackerHP::AliBusPatch*         busStruct  = 0x0;
149   
150   //   Loop over events  
151   Int_t iEvent = 0;
152   Int_t dataSize;
153   
154   while (rawReader->NextEvent()) {
155     
156     if (iEvent == maxEvent)
157       break;
158     
159     printf("Event %d\n",iEvent++);
160     
161     // read DDL while < 20 DDL
162     while(rawStream.NextDDL()) {
163       
164       if (rawStream.GetDDL() < minDDL || rawStream.GetDDL() > maxDDL)
165         continue;
166       
167       printf("\niDDL %d\n", rawStream.GetDDL());
168       
169       // loop over block structure
170       Int_t nBlock = rawStream.GetBlockCount();
171       for(Int_t iBlock = 0; iBlock < nBlock ;iBlock++){
172         
173         blkHeader = rawStream.GetBlockHeader(iBlock);
174         printf("Block %d Total length %d\n",iBlock,blkHeader->GetTotalLength());
175        
176         // loop over DSP structure
177         Int_t nDsp = rawStream.GetDspCount(iBlock);
178         for(Int_t iDsp = 0; iDsp < nDsp ;iDsp++){   //DSP loop
179           
180           dspHeader =  rawStream.GetDspHeader(iBlock, iDsp);
181           printf("Dsp %d length %d error word %d\n",iDsp,dspHeader->GetTotalLength(), dspHeader->GetErrorWord());
182           
183           // loop over BusPatch structure
184           Int_t nBusPatch = rawStream.GetBusPatchCount(iBlock, iDsp);
185           for(Int_t iBusPatch = 0; iBusPatch < nBusPatch; iBusPatch++) {  
186             
187             busStruct = rawStream.GetBusPatch(iBlock, iDsp, iBusPatch);
188             
189             // loop over data
190             dataSize = busStruct->GetLength();
191             for (Int_t iData = 0; iData < dataSize; iData++) {
192               
193               Int_t  manuId    = busStruct->GetManuId(iData);
194               Int_t  channelId = busStruct->GetChannelId(iData);
195               Int_t  charge    = busStruct->GetCharge(iData);
196               printf("buspatch %5d manuI %4d channel %3d charge %4d\n", 
197                      busStruct->GetBusPatchId(),
198                      manuId, 
199                      channelId, charge);
200             } // iData
201           } // iBusPatch
202         } // iDsp
203       } // iBlock
204     } // NextDDL
205   }// NextEvent
206   
207   delete rawReader;
208   timer.Print();
209 }
210
211
212 void MUONRawStreamTrackerExpert3(TString fileName = "./", Int_t maxEvent = 1000,  
213                                 Int_t minDDL = 0, Int_t maxDDL = 19)
214 {
215   /// This routine shows yet another alternate way to iterate over the DDL
216   /// structures compared to MUONRawStreamTrackerExpert().
217   
218   TStopwatch timer;
219   timer.Start(kTRUE);
220   
221   AliRawReader* rawReader = AliRawReader::Create(fileName.Data());
222   
223   // raw stream
224   AliMUONRawStreamTrackerHP rawStream(rawReader);
225   
226   // light weight interfaces to headers
227   const AliMUONRawStreamTrackerHP::AliBlockHeader*      blkHeader  = 0x0;
228   const AliMUONRawStreamTrackerHP::AliDspHeader*        dspHeader  = 0x0;
229   const AliMUONRawStreamTrackerHP::AliBusPatch*         busStruct  = 0x0;
230   
231   //   Loop over events  
232   Int_t iEvent = 0;
233   Int_t dataSize;
234   
235   while (rawReader->NextEvent()) {
236     
237     if (iEvent == maxEvent)
238       break;
239     
240     printf("Event %d\n",iEvent++);
241     
242     // read DDL while < 20 DDL
243     while(rawStream.NextDDL()) {
244       
245       if (rawStream.GetDDL() < minDDL || rawStream.GetDDL() > maxDDL)
246         continue;
247       
248       printf("\niDDL %d\n", rawStream.GetDDL());
249       
250       // loop over block structure
251       Int_t iBlock = 0;
252       blkHeader = rawStream.GetFirstBlockHeader();
253       while (blkHeader != NULL)
254       {
255         printf("Block %d Total length %d\n",iBlock,blkHeader->GetTotalLength());
256        
257         // loop over DSP structure
258         Int_t iDsp = 0;
259         dspHeader = blkHeader->GetFirstDspHeader();
260         while (dspHeader != NULL)
261         {
262           printf("Dsp %d length %d error word %d\n",iDsp,dspHeader->GetTotalLength(), dspHeader->GetErrorWord());
263           
264           // loop over BusPatch structure
265           Int_t iBusPatch = 0;
266           busStruct = dspHeader->GetFirstBusPatch();
267           while (busStruct != NULL)
268           {
269             // loop over data
270             dataSize = busStruct->GetLength();
271             for (Int_t iData = 0; iData < dataSize; iData++) {
272               
273               Int_t  manuId    = busStruct->GetManuId(iData);
274               Int_t  channelId = busStruct->GetChannelId(iData);
275               Int_t  charge    = busStruct->GetCharge(iData);
276               printf("buspatch %5d manuI %4d channel %3d charge %4d\n", 
277                      busStruct->GetBusPatchId(),
278                      manuId, 
279                      channelId, charge);
280             } // iData
281             busStruct = busStruct->Next();
282             iBusPatch++;
283           } // iBusPatch
284           dspHeader = dspHeader->Next();
285           iDsp++;
286         } // iDsp
287         blkHeader = blkHeader->Next();
288         iBlock++;
289       } // iBlock
290     } // NextDDL
291   }// NextEvent
292   
293   delete rawReader;
294   timer.Print();
295 }
296
297
298 void MUONRawStreamTrackerSimple(TString fileName = "./", Int_t maxEvent = 1000)
299 {
300   /// This routine shows how to use the high performance decoder's simple interface.
301
302   TStopwatch timer;
303   timer.Start(kTRUE);
304   
305   AliRawReader* rawReader = AliRawReader::Create(fileName.Data());
306   
307   // raw stream
308   AliMUONRawStreamTrackerHP rawStream(rawReader);    
309   
310   //   Loop over events  
311   Int_t iEvent = 0;
312   
313   while (rawReader->NextEvent()) {
314     
315     if (iEvent == maxEvent)
316       break;
317     
318     printf("Event %d\n",iEvent++);
319     
320     Int_t busPatch;
321     UShort_t manuId, adc;
322     UChar_t manuChannel;
323     
324     rawStream.First();
325     
326     while ( rawStream.Next(busPatch,manuId,manuChannel,adc) )
327     {      
328       printf("buspatch %5d manuI %4d channel %3d charge %4d\n", 
329              busPatch,manuId,manuChannel, adc);
330     }
331   }
332   
333   delete rawReader;
334   timer.Print();
335 }
336
337
338 void ShowErrors(const AliRawReader& rawReader)
339 {
340   for ( Int_t i = 0; i < rawReader.GetNumberOfErrorLogs(); ++i )
341   {
342     AliRawDataErrorLog* error = rawReader.GetErrorLog(i);
343     error->Print();
344   }
345
346   cout << Form("Number of error logs : %d (%d events)",
347                rawReader.GetNumberOfErrorLogs(),
348                rawReader.GetNumberOfEvents()) << endl;
349 }
350
351
352 void MUONRawStreamTrackerSimple2(TString fileName = "./", Int_t maxEvent = 1000)
353 {
354   /// This routine is an alternative to MUONRawStreamTrackerSimple() which is even faster.
355
356   TStopwatch timer;
357   timer.Start(kTRUE);
358   
359   AliRawReader* rawReader = AliRawReader::Create(fileName.Data());
360   
361   // raw stream
362   AliMUONRawStreamTrackerHP rawStream(rawReader);
363   rawStream.EnableRawReaderErrorLogger();
364   
365   //   Loop over events  
366   Int_t iEvent = 0;
367   
368   while (rawReader->NextEvent()) {
369     
370     if (iEvent == maxEvent)
371       break;
372     
373     printf("Event %d\n",iEvent++);
374     
375     UShort_t manuId, adc;
376     UChar_t manuChannel;
377     
378     rawStream.First();
379     const AliMUONRawStreamTrackerHP::AliBusPatch* buspatch = NULL;
380     while ((buspatch = rawStream.Next()) != NULL)
381     {
382       for (UInt_t i = 0; i < buspatch->GetDataCount(); i++)
383       {
384         buspatch->GetData(i, manuId, manuChannel, adc);
385         printf("buspatch %5d manuI %4d channel %3d charge %4d\n", 
386                buspatch->GetBusPatchId(), manuId, manuChannel, adc);
387       }
388     }
389   }
390
391   ShowErrors(*rawReader);
392   
393   delete rawReader;
394   timer.Print();
395 }
396
397 void MUONRawStreamTrackerErrorCount(TString fileName = "collection://filelist", Int_t maxEvent = -1)
398 {
399   /// This routine is just a loop to get the error log at the end
400   
401   TStopwatch timer;
402   timer.Start(kTRUE);
403   
404   AliRawReader* rawReader = AliRawReader::Create(fileName.Data());
405   
406   // raw stream
407   AliMUONRawStreamTrackerHP rawStream(rawReader);
408   rawStream.DisableWarnings();    
409
410   AliMUONLogger logger;
411   
412   rawStream.EnableMUONErrorLogger();  
413   rawStream.SetMUONErrorLogger(&logger);    
414   rawStream.SetLoggingDetailLevel(AliMUONRawStreamTrackerHP::kMediumErrorDetail);
415   
416   //   Loop over events  
417   Int_t iEvent = 0;
418   
419   while (rawReader->NextEvent()) 
420   {    
421     if (iEvent == maxEvent) break;
422     
423     rawStream.First();
424
425     const AliMUONRawStreamTrackerHP::AliBusPatch* buspatch = NULL;
426     
427     while ((buspatch = rawStream.Next()) != NULL)
428     {
429     }
430     
431     ++iEvent;
432   }
433   
434   logger.Print();
435   
436 //  ShowErrors(*rawReader);
437
438   delete rawReader;
439   timer.Print();
440 }
441