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