minor coverity defect: added protection for self-assignment
[u/mrichter/AliRoot.git] / MUON / MUONRawStreamTrigger.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 MUONRawStreamTrigger.C
20 /// \brief Macro for reading trigger raw data
21 ///
22 /// \author Ch. Finck, Subatech, April 2006
23 ///
24 /// Added example routines to show how to use the interface of the high
25 /// performance decoder AliMUONRawStreamTriggerrHP.
26 ///    --  Artur Szostak <artursz@iafrica.com>
27 ///
28 /// Implement "digits" iterator.
29 /// This macro is interface with AliRawReader for RAW.
30 /// The different stucture of the patload are readout and stored in TClonesArray
31 /// with AliMUONRawStreamTrigger class.
32 /// The macro just simply reads again the TClonesArray contents.
33 /// The parameter of each structure could be seen in the container classes
34 /// AliMUONDarcHeader, AliMUONRegHeader, AliMUONLocalStruct.
35 /// The class AliMUONDDLTrigger manages the structure containers.
36 /// The number of structures in the rawdata file could be set.
37 /// The DATE format reading is no more supported please use the MUONTRGda code.
38
39
40 #if !defined(__CINT__) || defined(__MAKECINT__)
41
42 // RAW includes
43 #include "AliRawReader.h"
44 #include "AliRawReaderFile.h"
45 #include "AliRawReaderRoot.h"
46
47 // MUON includes
48 #include "AliMUONRawStreamTrigger.h"
49 #include "AliMUONRawStreamTriggerHP.h"
50 #include "AliMUONDarcHeader.h"
51 #include "AliMUONRegHeader.h"
52 #include "AliMUONLocalStruct.h"
53 #include "AliMUONDDLTrigger.h"
54 #include "AliMpTriggerCrate.h"
55 #include "AliMpDDLStore.h"
56 #include "AliMpCDB.h"
57
58 #include "TStopwatch.h"
59
60
61 #endif
62
63 void MUONRawStreamTrigger(Int_t maxEvent = 1, Int_t minDDL = 0, Int_t maxDDL = 1, TString fileName = "./")
64 {
65    
66    TStopwatch timer;
67    timer.Start(kTRUE);
68
69    AliRawReader* rawReader = AliRawReader::Create(fileName.Data());
70
71    // Load mapping
72      if ( ! AliMpCDB::LoadDDLStore() ) {
73        printf("Could not access mapping from OCDB !\n");
74      }
75
76    // raw stream
77    AliMUONRawStreamTrigger* rawStream   = new AliMUONRawStreamTrigger(rawReader);
78
79    // set the number ofreg & local that are PRESENT in the rawdata file
80    // it's NOT the number to be read.
81    // default wise set to 8, 16 respectively.
82    //    rawStream->SetMaxReg(2);
83    //    rawStream->SetMaxLoc(xx);
84
85    // containers
86    AliMUONDDLTrigger*       ddlTrigger  = 0x0;
87    AliMUONDarcHeader*       darcHeader  = 0x0;
88    AliMUONRegHeader*        regHeader   = 0x0;
89    AliMUONLocalStruct*      localStruct = 0x0;
90
91
92    // Loop over events  
93    Int_t iEvent = 0;
94
95    while (rawReader->NextEvent()) {
96
97      if (iEvent == maxEvent)
98        break;
99
100      printf("Event %d\n",iEvent++);
101
102      // read DDL while < 2 DDL
103      while(rawStream->NextDDL()) {
104
105       if (rawStream->GetDDL() < minDDL || rawStream->GetDDL() > maxDDL)
106          continue;
107
108        printf("\niDDL %d\n", rawStream->GetDDL());
109
110        ddlTrigger = rawStream->GetDDLTrigger();
111        darcHeader = ddlTrigger->GetDarcHeader();
112
113        printf("Global output %x\n", (Int_t)darcHeader->GetGlobalOutput());
114
115        // loop over regional structures
116        Int_t nReg = darcHeader->GetRegHeaderEntries();
117        for(Int_t iReg = 0; iReg < nReg ;iReg++){   //REG loop
118
119 //       printf("RegionalId %d\n", iReg);
120
121          regHeader =  darcHeader->GetRegHeaderEntry(iReg);
122          //  printf("Reg length %d\n",regHeader->GetHeaderLength());
123
124          // crate info  
125          AliMpTriggerCrate* crate = AliMpDDLStore::Instance()->
126                                     GetTriggerCrate(rawStream->GetDDL(), iReg);
127
128          // loop over local structures
129          Int_t nLocal = regHeader->GetLocalEntries();
130          for(Int_t iLocal = 0; iLocal < nLocal; iLocal++) {  
131
132            localStruct = regHeader->GetLocalEntry(iLocal);
133
134            Int_t iLocCard = crate->GetLocalBoardId(localStruct->GetId());
135
136            if ( !iLocCard ) continue; // empty slot
137
138            // check if trigger 
139            if (localStruct->GetTriggerX() 
140                || localStruct->GetTriggerY()) { // no empty data
141
142              printf("LocalId %d\n", localStruct->GetId());
143
144              Int_t loStripX  = (Int_t)localStruct->GetXPos();
145              Int_t loStripY  = (Int_t)localStruct->GetYPos();
146              Int_t loDev     = (Int_t)localStruct->GetXDev();
147                
148              printf("iLocCard: %d, XPos: %d, YPos: %d Dev: %d\n", iLocCard, loStripX, loStripY, loDev);
149
150            }
151          } // iLocal
152        } // iReg
153      } // NextDDL
154    }// NextEvent
155
156    delete rawReader;
157    delete rawStream;
158
159    timer.Print();
160
161 }
162
163
164 void MUONRawStreamTriggerHPExpert(Int_t maxEvent = 1, Int_t minDDL = 0, Int_t maxDDL = 1, TString fileName = "./")
165 {
166    /// Decodes raw MUON trigger data using the fast decoder.
167    
168    TStopwatch timer;
169    timer.Start(kTRUE);
170
171    AliRawReader* rawReader = AliRawReader::Create(fileName.Data());
172
173    // Load mapping
174    if ( ! AliMpCDB::LoadDDLStore() ) {
175      printf("Could not access mapping from OCDB !\n");
176    }
177
178    // raw stream
179    AliMUONRawStreamTriggerHP* rawStream = new AliMUONRawStreamTriggerHP(rawReader);
180
181    // Light weight interfaces to the raw data.
182    const AliMUONRawStreamTriggerHP::AliHeader*          darcHeader  = 0x0;
183    const AliMUONRawStreamTriggerHP::AliRegionalHeader*  regHeader   = 0x0;
184    const AliMUONRawStreamTriggerHP::AliLocalStruct*     localStruct = 0x0;
185
186    // Loop over events.
187    Int_t iEvent = 0;
188
189    while (rawReader->NextEvent()) {
190
191      if (iEvent == maxEvent)
192        break;
193
194      printf("Event %d\n",iEvent++);
195
196      // read DDL while < 2 DDL
197      while(rawStream->NextDDL()) {
198
199       if (rawStream->GetDDL() < minDDL || rawStream->GetDDL() > maxDDL)
200          continue;
201
202        printf("\niDDL %d\n", rawStream->GetDDL());
203
204        darcHeader = rawStream->GetHeaders();
205
206        printf("Global output %x\n", (Int_t)darcHeader->GetGlobalOutput());
207
208        // loop over regional structures
209        Int_t nReg = (Int_t) rawStream->GetRegionalHeaderCount();
210        for(Int_t iReg = 0; iReg < nReg ;iReg++){   //REG loop
211
212 //       printf("RegionalId %d\n", iReg);
213
214          regHeader =  rawStream->GetRegionalHeader(iReg);
215
216          // crate info
217          AliMpTriggerCrate* crate = AliMpDDLStore::Instance()->
218                                     GetTriggerCrate(rawStream->GetDDL(), iReg);
219
220          // loop over local structures
221          Int_t nLocal = rawStream->GetLocalStructCount(iReg);
222          for(Int_t iLocal = 0; iLocal < nLocal; iLocal++) {
223
224            localStruct = rawStream->GetLocalStruct(iReg, iLocal);
225
226            Int_t iLocCard = crate->GetLocalBoardId(localStruct->GetId());
227
228            if ( !iLocCard ) continue; // empty slot
229                 
230            // check if trigger 
231            if (localStruct->GetTriggerX() 
232                || localStruct->GetTriggerY()) { // no empty data
233
234              printf("LocalId %d\n", localStruct->GetId());
235
236              Int_t loStripX  = (Int_t)localStruct->GetXPos();
237              Int_t loStripY  = (Int_t)localStruct->GetYPos();
238              Int_t loDev     = (Int_t)localStruct->GetXDev();
239
240              printf("iLocCard: %d, XPos: %d, YPos: %d Dev: %d\n", iLocCard, loStripX, loStripY, loDev);
241
242            }
243          } // iLocal
244        } // iReg
245      } // NextDDL
246    }// NextEvent
247
248    delete rawReader;
249    delete rawStream;
250
251    timer.Print();
252
253 }
254
255
256 void MUONRawStreamTriggerHPExpert2(Int_t maxEvent = 1, Int_t minDDL = 0, Int_t maxDDL = 1, TString fileName = "./")
257 {
258    /// Decodes raw MUON trigger data using the fast decoder.
259    /// This method shows a slightly different method of iteration over the
260    /// data using the AliMUONRawStreamTriggerHP interface.
261    
262    TStopwatch timer;
263    timer.Start(kTRUE);
264
265    AliRawReader* rawReader = AliRawReader::Create(fileName.Data());
266
267    // Load mapping
268    if ( ! AliMpCDB::LoadDDLStore() ) {
269      printf("Could not access mapping from OCDB !\n");
270    }
271
272    // raw stream
273    AliMUONRawStreamTriggerHP* rawStream = new AliMUONRawStreamTriggerHP(rawReader);
274
275    // Light weight interfaces to the raw data.
276    const AliMUONRawStreamTriggerHP::AliHeader*          darcHeader  = 0x0;
277    const AliMUONRawStreamTriggerHP::AliRegionalHeader*  regHeader   = 0x0;
278    const AliMUONRawStreamTriggerHP::AliLocalStruct*     localStruct = 0x0;
279
280    // Loop over events.
281    Int_t iEvent = 0;
282
283    while (rawReader->NextEvent()) {
284
285      if (iEvent == maxEvent)
286        break;
287
288      printf("Event %d\n",iEvent++);
289
290      // read DDL while < 2 DDL
291      while(rawStream->NextDDL()) {
292
293       if (rawStream->GetDDL() < minDDL || rawStream->GetDDL() > maxDDL)
294          continue;
295
296        printf("\niDDL %d\n", rawStream->GetDDL());
297
298        darcHeader = rawStream->GetHeaders();
299
300        printf("Global output %x\n", (Int_t)darcHeader->GetGlobalOutput());
301
302        // loop over regional structures
303        Int_t nReg = (Int_t) rawStream->GetRegionalHeaderCount();
304        for(Int_t iReg = 0; iReg < nReg ;iReg++){   //REG loop
305
306 //       printf("RegionalId %d\n", iReg);
307
308          regHeader =  rawStream->GetRegionalHeader(iReg);
309
310          // crate info
311          AliMpTriggerCrate* crate = AliMpDDLStore::Instance()->
312                                     GetTriggerCrate(rawStream->GetDDL(), iReg);
313
314          // loop over local structures
315          Int_t nLocal = regHeader->GetLocalStructCount();
316          for(Int_t iLocal = 0; iLocal < nLocal; iLocal++) {
317
318            localStruct = regHeader->GetLocalStruct(iLocal);
319
320            Int_t iLocCard = crate->GetLocalBoardId(localStruct->GetId());
321
322            if ( !iLocCard ) continue; // empty slot
323                 
324            // check if trigger 
325            if (localStruct->GetTriggerX() 
326                || localStruct->GetTriggerY()) { // no empty data
327
328              printf("LocalId %d\n", localStruct->GetId());
329
330              Int_t loStripX  = (Int_t)localStruct->GetXPos();
331              Int_t loStripY  = (Int_t)localStruct->GetYPos();
332              Int_t loDev     = (Int_t)localStruct->GetXDev();
333
334              printf("iLocCard: %d, XPos: %d, YPos: %d Dev: %d\n", iLocCard, loStripX, loStripY, loDev);
335
336            }
337          } // iLocal
338        } // iReg
339      } // NextDDL
340    }// NextEvent
341
342    delete rawReader;
343    delete rawStream;
344
345    timer.Print();
346
347 }
348
349
350 void MUONRawStreamTriggerHPExpert3(Int_t maxEvent = 1, Int_t minDDL = 0, Int_t maxDDL = 1, TString fileName = "./")
351 {
352    /// Decodes raw MUON trigger data using the fast decoder.
353    /// This method shows a jet another method of iteration over the
354    /// data using the AliMUONRawStreamTriggerHP interface.
355    
356    TStopwatch timer;
357    timer.Start(kTRUE);
358
359    AliRawReader* rawReader = AliRawReader::Create(fileName.Data());
360
361    // Load mapping
362    if ( ! AliMpCDB::LoadDDLStore() ) {
363      printf("Could not access mapping from OCDB !\n");
364    }
365
366    // raw stream
367    AliMUONRawStreamTriggerHP* rawStream = new AliMUONRawStreamTriggerHP(rawReader);
368
369    // Light weight interfaces to the raw data.
370    const AliMUONRawStreamTriggerHP::AliHeader*          darcHeader  = 0x0;
371    const AliMUONRawStreamTriggerHP::AliRegionalHeader*  regHeader   = 0x0;
372    const AliMUONRawStreamTriggerHP::AliLocalStruct*     localStruct = 0x0;
373
374    // Loop over events.
375    Int_t iEvent = 0;
376
377    while (rawReader->NextEvent()) {
378
379      if (iEvent == maxEvent)
380        break;
381
382      printf("Event %d\n",iEvent++);
383
384      // read DDL while < 2 DDL
385      while(rawStream->NextDDL()) {
386
387       if (rawStream->GetDDL() < minDDL || rawStream->GetDDL() > maxDDL)
388          continue;
389
390        printf("\niDDL %d\n", rawStream->GetDDL());
391
392        darcHeader = rawStream->GetHeaders();
393
394        printf("Global output %x\n", (Int_t)darcHeader->GetGlobalOutput());
395
396        // loop over regional structures
397        Int_t iReg = 0;
398        regHeader = rawStream->GetFirstRegionalHeader();
399        while (regHeader != NULL)
400        {
401 //       printf("RegionalId %d\n", iReg);
402
403          regHeader =  rawStream->GetRegionalHeader(iReg);
404
405          // crate info
406          AliMpTriggerCrate* crate = AliMpDDLStore::Instance()->
407                                     GetTriggerCrate(rawStream->GetDDL(), iReg);
408
409          // loop over local structures
410          Int_t iLocal = 0;
411          localStruct = regHeader->GetFirstLocalStruct();
412          while (localStruct != NULL)
413          {
414            Int_t iLocCard = crate->GetLocalBoardId(localStruct->GetId());
415            if ( !iLocCard ) continue; // empty slot
416                 
417            // check if trigger 
418            if (localStruct->GetTriggerX() 
419                || localStruct->GetTriggerY()) { // no empty data
420
421              printf("LocalId %d\n", localStruct->GetId());
422
423              Int_t loStripX  = (Int_t)localStruct->GetXPos();
424              Int_t loStripY  = (Int_t)localStruct->GetYPos();
425              Int_t loDev     = (Int_t)localStruct->GetXDev();
426
427              printf("iLocCard: %d, XPos: %d, YPos: %d Dev: %d\n", iLocCard, loStripX, loStripY, loDev);
428
429            }
430            iLocal++;
431            localStruct = localStruct->Next();
432          } // iLocal
433          iReg++;
434          regHeader = regHeader->Next();
435        } // iReg
436      } // NextDDL
437    }// NextEvent
438
439    delete rawReader;
440    delete rawStream;
441
442    timer.Print();
443
444 }
445
446
447 void MUONRawStreamTriggerSimple(Int_t maxEvent = 1, TString fileName = "./")
448 {
449   /// Reads the raw data in fileName, using a simplified interface (iterator
450   /// over local structure response).
451
452   TStopwatch timer;
453   timer.Start(kTRUE);
454
455    AliRawReader* rawReader = 0x0;
456
457    if (fileName.EndsWith("/")) {
458      rawReader = new AliRawReaderFile(fileName);// DDL files
459    } else if (fileName.EndsWith(".root")) {
460      rawReader = new AliRawReaderRoot(fileName);
461    } 
462
463    // raw stream
464    AliMUONRawStreamTrigger* rawStream   = new AliMUONRawStreamTrigger(rawReader);
465
466    // set the number of reg & local that are PRESENT in the rawdata file
467    // it's NOT the number to be read.
468    // default wise set to 8, 16 respectively.
469    //    rawStream->SetMaxReg(2);
470    //    rawStream->SetMaxLoc(xx);
471
472    UChar_t id;   
473    UChar_t dec;
474    Bool_t trigY; 
475    UChar_t yPos; 
476    UChar_t sXDev; 
477    UChar_t xDev;
478    UChar_t xPos;
479
480    Bool_t triggerX; 
481    Bool_t triggerY; 
482
483  
484    TArrayS xPattern; 
485    TArrayS yPattern;
486
487    // Loop over events  
488    Int_t iEvent = 0;
489
490    while (rawReader->NextEvent()) {
491
492      if (iEvent == maxEvent)
493          break;
494
495      printf("Event %d\n",iEvent++);
496
497      rawStream->First();
498
499      // read while there are digits
500      while( rawStream->Next(id, dec, trigY, yPos, sXDev, xDev, xPos,
501                             triggerX, triggerY, xPattern, yPattern) ) 
502      {
503        if ( triggerX || triggerY )  // no empty data
504            printf("iLocCard: %d, XPos: %d, YPos: %d Dev: %d\n", id, xPos, yPos, xDev);
505
506      }// Next
507   
508    }// NextEvent
509
510    delete rawReader;
511    delete rawStream;
512
513    timer.Print();
514
515 }
516
517
518 void MUONRawStreamTriggerHPSimple(Int_t maxEvent = 1, TString fileName = "./")
519 {
520   /// Reads the raw data in fileName, using the simplified interface of the
521   /// high performance decoder.
522
523   TStopwatch timer;
524   timer.Start(kTRUE);
525
526   AliRawReader* rawReader = AliRawReader::Create(fileName.Data());
527   AliMUONRawStreamTriggerHP* rawStream   = new AliMUONRawStreamTriggerHP(rawReader);
528
529   UChar_t id;
530   UChar_t dec;
531   Bool_t trigY;
532   UChar_t yPos;
533   UChar_t sXDev;
534   UChar_t xDev;
535   UChar_t xPos;
536   Bool_t triggerX;
537   Bool_t triggerY;
538   TArrayS xPattern;
539   TArrayS yPattern;
540
541   // Loop over events
542   Int_t iEvent = 0;
543
544   while (rawReader->NextEvent())
545   {
546
547     if (iEvent == maxEvent)
548        break;
549
550      printf("Event %d\n", iEvent++);
551
552      rawStream->First();
553
554      // read while there are digits
555      while ( rawStream->Next(id, dec, trigY, yPos, sXDev, xDev, xPos,
556                             triggerX, triggerY, xPattern, yPattern) )
557      {
558        if ( triggerX || triggerY )  // no empty data
559           printf("iLocCard: %d, XPos: %d, YPos: %d Dev: %d\n", id, xPos, yPos, xDev);
560      }// Next
561   }// NextEvent
562
563   delete rawReader;
564   delete rawStream;
565
566   timer.Print();
567 }
568
569
570 void MUONRawStreamTriggerHPSimple2(Int_t maxEvent = 1, TString fileName = "./")
571 {
572   /// Reads the raw data in fileName, using the simplified interface of the
573   /// high performance decoder.
574
575   TStopwatch timer;
576   timer.Start(kTRUE);
577
578   AliRawReader* rawReader = AliRawReader::Create(fileName.Data());
579   AliMUONRawStreamTriggerHP* rawStream   = new AliMUONRawStreamTriggerHP(rawReader);
580
581   const AliMUONRawStreamTriggerHP::AliLocalStruct* localStruct;
582
583   // Loop over events
584   Int_t iEvent = 0;
585
586   while (rawReader->NextEvent())
587   {
588
589     if (iEvent == maxEvent)
590        break;
591
592      printf("Event %d\n", iEvent++);
593
594      rawStream->First();
595
596      // read while there are digits
597      while ( (localStruct = rawStream->Next()) != NULL )
598      {
599        if ( localStruct->GetTriggerX() || localStruct->GetTriggerY() )  // no empty data
600           printf("iLocCard: %d, XPos: %d, YPos: %d Dev: %d\n",
601                 localStruct->GetId(),
602                 localStruct->GetXPos(),
603                 localStruct->GetYPos(),
604                 localStruct->GetXDev()
605           );
606      }// Next
607   }// NextEvent
608
609   delete rawReader;
610   delete rawStream;
611
612   timer.Print();
613 }
614