RAW/AliRawReaderDateV3.cxx

   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 ///////////////////////////////////////////////////////////////////////////////
  19 ///
  20 /// This is a class for reading raw data from a date file or event (version 3).
  21 ///
  22 /// The AliRawReaderDateV3 is constructed either with a pointer to a
  23 /// date event or with a file name and an event number.
  24 ///
  25 ///////////////////////////////////////////////////////////////////////////////
  26
  27 #include "AliRawReaderDateV3.h"
  28
  29 struct eventHeaderStruct {
  30   Int_t  size;          /* size of event in Bytes  */
  31   UInt_t magic;         /* magic number used for consistency check */
  32   UInt_t type;          /* event type */
  33   UInt_t headLen;       /* size of header in bytes */
  34   UInt_t runNb;         /* run number */
  35   UInt_t burstNb;       /* burst number */
  36   UInt_t nbInRun;       /* event number in run */
  37   UInt_t nbInBurst;     /* event number in burst */
  38   UInt_t triggerNb;     /* trigger number for this detector */
  39   UInt_t fileSeqNb;     /* file sequence number for multifiles run */
  40   UInt_t detectorId[3]; /* detector identification */
  41   UInt_t time;          /* time in seconds since 0.00 GMT 1.1.1970 */
  42   UInt_t usec;          /* microseconds */
  43   UInt_t errorCode;
  44   UInt_t deadTime;
  45   UInt_t deadTimeusec;
  46   UInt_t typeAttribute[2]; /* event type id mask */
  47 };
  48
  49 #define EVENT_MAGIC_NUMBER         ((UInt_t)0xDA1E5AFE)
  50
  51
  52 ClassImp(AliRawReaderDateV3)
  53
  54
  55 AliRawReaderDateV3::AliRawReaderDateV3(void* event) :
  56   fFile(NULL),
  57   fEvent(NULL),
  58   fSubEvent(NULL),
  59   fPosition(NULL),
  60   fEnd(NULL)
  61 {
  62 // create an object to read digits from the given date event
  63
  64   fEvent = (eventHeaderStruct*) event;
  65 }
  66
  67 AliRawReaderDateV3::AliRawReaderDateV3(const char* fileName,
  68                                        Int_t eventNumber) :
  69   fFile(NULL),
  70   fEvent(NULL),
  71   fSubEvent(NULL),
  72   fPosition(NULL),
  73   fEnd(NULL)
  74 {
  75 // create an object to read digits from the given date event
  76
  77   fFile = fopen(fileName, "rb");
  78   if (!fFile) {
  79     Error("AliRawReaderDateV3", "could not open file %s", fileName);
  80     fIsValid = kFALSE;
  81     return;
  82   }
  83   if (eventNumber < 0) return;
  84
  85   eventHeaderStruct header;
  86   UInt_t headerSize = sizeof(eventHeaderStruct);
  87   while (fread(&header, 1, headerSize, fFile) == headerSize) {
  88     if (eventNumber == 0) {
  89       UChar_t* buffer = new UChar_t[header.size];
  90       fseek(fFile, -(long)headerSize, SEEK_CUR);
  91       if (Int_t(fread(buffer, 1, header.size, fFile)) != header.size) break;
  92       fEvent = (eventHeaderStruct*) buffer;
  93       break;
  94     }
  95     fseek(fFile, header.size-headerSize, SEEK_CUR);
  96     eventNumber--;
  97   }
  98 }
  99
 100 AliRawReaderDateV3::AliRawReaderDateV3(const AliRawReaderDateV3& rawReader) :
 101   AliRawReader(rawReader),
 102   fFile(rawReader.fFile),
 103   fEvent(rawReader.fEvent),
 104   fSubEvent(rawReader.fSubEvent),
 105   fPosition(rawReader.fPosition),
 106   fEnd(rawReader.fEnd)
 107
 108 {
 109 // copy constructor
 110
 111   Fatal("AliRawReaderDateV3", "copy constructor not implemented");
 112 }
 113
 114 AliRawReaderDateV3& AliRawReaderDateV3::operator = (const AliRawReaderDateV3&
 115                                                 /*rawReader*/)
 116 {
 117 // assignment operator
 118
 119   Fatal("operator =", "assignment operator not implemented");
 120   return *this;
 121 }
 122
 123 AliRawReaderDateV3::~AliRawReaderDateV3()
 124 {
 125 // destructor
 126
 127   if (fFile) {
 128     delete[] fEvent;
 129     fclose(fFile);
 130   }
 131 }
 132
 133
 134 UInt_t AliRawReaderDateV3::GetType() const
 135 {
 136 // get the type from the event header
 137
 138   if (!fEvent) return 0;
 139   return fEvent->type;
 140 }
 141
 142 UInt_t AliRawReaderDateV3::GetRunNumber() const
 143 {
 144 // get the run number from the event header
 145
 146   if (!fEvent) return 0;
 147   return fEvent->runNb;
 148 }
 149
 150 const UInt_t* AliRawReaderDateV3::GetEventId() const
 151 {
 152 // get the event id from the event header
 153
 154   if (!fEvent) return NULL;
 155   return &(fEvent->nbInRun);
 156 }
 157
 158 const UInt_t* AliRawReaderDateV3::GetTriggerPattern() const
 159 {
 160 // get the trigger pattern from the event header
 161
 162   return NULL;
 163 }
 164
 165 const UInt_t* AliRawReaderDateV3::GetDetectorPattern() const
 166 {
 167 // get the detector pattern from the event header
 168
 169   if (!fEvent) return NULL;
 170   return fEvent->detectorId;
 171 }
 172
 173 const UInt_t* AliRawReaderDateV3::GetAttributes() const
 174 {
 175 // get the type attributes from the event header
 176
 177   if (!fEvent) return NULL;
 178   return fEvent->typeAttribute;
 179 }
 180
 181 const UInt_t* AliRawReaderDateV3::GetSubEventAttributes() const
 182 {
 183 // get the type attributes from the sub event header
 184
 185   if (!fSubEvent) return NULL;
 186   return fSubEvent->typeAttribute;
 187 }
 188
 189 UInt_t AliRawReaderDateV3::GetLDCId() const
 190 {
 191 // get the LDC Id from the event header
 192
 193   return UInt_t(-1);
 194 }
 195
 196 UInt_t AliRawReaderDateV3::GetGDCId() const
 197 {
 198 // get the GDC Id from the event header
 199
 200   return UInt_t(-1);
 201 }
 202
 203 UInt_t AliRawReaderDateV3::GetTimestamp() const
 204 {
 205 // get the timestamp from the event header
 206
 207   if (!fEvent) return 0;
 208   return fEvent->time;
 209 }
 210
 211 Int_t AliRawReaderDateV3::GetEquipmentSize() const
 212 {
 213 // get the size of the equipment
 214
 215   if (!fSubEvent) return 0;
 216   return fSubEvent->size;
 217 }
 218
 219 Int_t AliRawReaderDateV3::GetEquipmentType() const
 220 {
 221 // get the type from the equipment header
 222
 223   return 0;
 224 }
 225
 226 Int_t AliRawReaderDateV3::GetEquipmentId() const
 227 {
 228 // get the ID from the equipment header
 229
 230   return 0;
 231 }
 232
 233 const UInt_t* AliRawReaderDateV3::GetEquipmentAttributes() const
 234 {
 235 // get the attributes from the equipment header
 236
 237   return 0;
 238 }
 239
 240 Int_t AliRawReaderDateV3::GetEquipmentElementSize() const
 241 {
 242 // get the basic element size from the equipment header
 243
 244   return 0;
 245 }
 246
 247 Int_t AliRawReaderDateV3::GetEquipmentHeaderSize() const
 248 {
 249 // get the size of the equipment header
 250
 251   return 0;
 252 }
 253
 254 Bool_t AliRawReaderDateV3::ReadHeader()
 255 {
 256 // read a data header at the current position
 257 // returns kFALSE if the data header could not be read
 258
 259   fErrorCode = 0;
 260
 261   fHeader = NULL;
 262   if (!fEvent) return kFALSE;
 263   // check whether there are sub events
 264   if (fEvent->size <= Int_t(fEvent->headLen)) return kFALSE;
 265
 266   do {
 267     // skip payload (if event was not selected)
 268     if (fCount > 0) fPosition += fCount;
 269
 270     // check for end of event data
 271     if (fPosition >= ((UChar_t*)fEvent)+fEvent->size) return kFALSE;
 272     if ((fEvent->detectorId[2] & 0x8000) != 0x8000) {
 273       fSubEvent = fEvent;   // no super event
 274     } else if (fSubEvent) {
 275       fSubEvent = (eventHeaderStruct*) (((UChar_t*)fSubEvent) +
 276                                         fSubEvent->size);
 277     } else {
 278       fSubEvent = (eventHeaderStruct*) (((UChar_t*)fEvent) +
 279                                         fEvent->headLen);
 280     }
 281
 282     // check the magic word of the sub event
 283     if (fSubEvent->magic != EVENT_MAGIC_NUMBER) {
 284       Error("ReadHeader", "wrong magic number in sub event!\n"
 285             " run: %d  event: %d\n",
 286             fSubEvent->runNb, fSubEvent->nbInRun);
 287       fErrorCode = kErrMagic;
 288       return kFALSE;
 289     }
 290
 291     // continue if no data in the subevent
 292     if (fSubEvent->size == Int_t(fSubEvent->headLen)) {
 293       fPosition = fEnd = ((UChar_t*)fSubEvent) + fSubEvent->size;
 294       fCount = 0;
 295       continue;
 296     }
 297
 298     fCount = 0;
 299     fPosition = ((UChar_t*)fSubEvent) + sizeof(eventHeaderStruct);
 300     fEnd = ((UChar_t*)fSubEvent) + fSubEvent->size;
 301
 302     // continue with the next sub event if no data left in the payload
 303     if (fPosition >= fEnd) continue;
 304
 305     if (fRequireHeader) {
 306       // check that there are enough bytes left for the data header
 307       if (fPosition + sizeof(AliRawDataHeader) > fEnd) {
 308         Error("ReadHeader", "could not read data header data!");
 309         Warning("ReadHeader", "skipping %d bytes\n"
 310                 " run: %d  event: %d\n",
 311                 fEnd - fPosition, fSubEvent->runNb, fSubEvent->nbInRun);
 312         fCount = 0;
 313         fPosition = fEnd;
 314         fErrorCode = kErrNoDataHeader;
 315         continue;
 316       }
 317
 318       // "read" the data header
 319       fHeader = (AliRawDataHeader*) fPosition;
 320       if ((fPosition + fHeader->fSize) != fEnd) {
 321         if (fHeader->fSize != 0xFFFFFFFF)
 322           Warning("ReadHeader",
 323                   "raw data size found in the header is wrong (%d != %d)! Using the equipment size instead !",
 324                   fHeader->fSize, fEnd - fPosition);
 325         fHeader->fSize = fEnd - fPosition;
 326       }
 327       fPosition += sizeof(AliRawDataHeader);
 328     }
 329
 330     if (fHeader && (fHeader->fSize != 0xFFFFFFFF)) {
 331       fCount = fHeader->fSize - sizeof(AliRawDataHeader);
 332
 333       // check consistency of data size in the header and in the sub event
 334       if (fPosition + fCount > fEnd) {
 335         Error("ReadHeader", "size in data header exceeds event size!");
 336         Warning("ReadHeader", "skipping %d bytes\n"
 337                 " run: %d  event: %d\n",
 338                 fEnd - fPosition, fSubEvent->runNb, fSubEvent->nbInRun);
 339         fCount = 0;
 340         fPosition = fEnd;
 341         fErrorCode = kErrSize;
 342         continue;
 343       }
 344
 345     } else {
 346       fCount = fEnd - fPosition;
 347     }
 348
 349   } while (!IsSelected());
 350
 351   return kTRUE;
 352 }
 353
 354 Bool_t AliRawReaderDateV3::ReadNextData(UChar_t*& data)
 355 {
 356 // reads the next payload at the current position
 357 // returns kFALSE if the data could not be read
 358
 359   fErrorCode = 0;
 360   while (fCount == 0) {
 361     if (!ReadHeader()) return kFALSE;
 362   }
 363   data = fPosition;
 364   fPosition += fCount;
 365   fCount = 0;
 366   return kTRUE;
 367 }
 368
 369 Bool_t AliRawReaderDateV3::ReadNext(UChar_t* data, Int_t size)
 370 {
 371 // reads the next block of data at the current position
 372 // returns kFALSE if the data could not be read
 373
 374   fErrorCode = 0;
 375   if (fPosition + size > fEnd) {
 376     Error("ReadNext", "could not read data!");
 377     fErrorCode = kErrOutOfBounds;
 378     return kFALSE;
 379   }
 380   memcpy(data, fPosition, size);
 381   fPosition += size;
 382   fCount -= size;
 383   return kTRUE;
 384 }
 385
 386
 387 Bool_t AliRawReaderDateV3::Reset()
 388 {
 389 // reset the current position to the beginning of the event
 390
 391   fSubEvent = NULL;
 392   fCount = 0;
 393   fPosition = fEnd = NULL;
 394   return kTRUE;
 395 }
 396
 397
 398 Bool_t AliRawReaderDateV3::NextEvent()
 399 {
 400 // go to the next event in the date file
 401
 402   if (!fFile) return kFALSE;
 403
 404   Reset();
 405   eventHeaderStruct header;
 406   UInt_t headerSize = sizeof(eventHeaderStruct);
 407   if (fEvent) delete[] fEvent;
 408   fEvent = &header;
 409
 410   while (fread(&header, 1, headerSize, fFile) == headerSize) {
 411     if (!IsEventSelected()) {
 412       fseek(fFile, header.size-headerSize, SEEK_CUR);
 413       continue;
 414     }
 415     UChar_t* buffer = new UChar_t[header.size];
 416     fseek(fFile, -(long)headerSize, SEEK_CUR);
 417     if (Int_t(fread(buffer, 1, header.size, fFile)) != header.size) {
 418       Error("NextEvent", "could not read event from file");
 419       delete[] buffer;
 420       break;
 421     }
 422     fEvent = (eventHeaderStruct*) buffer;
 423     fEventNumber++;
 424     return kTRUE;
 425   };
 426
 427   fEvent = NULL;
 428   return kFALSE;
 429 }
 430
 431 Bool_t AliRawReaderDateV3::RewindEvents()
 432 {
 433 // go back to the beginning of the date file
 434
 435   if (!fFile) return kFALSE;
 436
 437   fseek(fFile, 0, SEEK_SET);
 438   fEventNumber = -1;
 439   return Reset();
 440 }
 441
 442
 443 Int_t AliRawReaderDateV3::CheckData() const
 444 {
 445 // check the consistency of the data
 446
 447   if (!fEvent) return 0;
 448   // check whether there are sub events
 449   if (fEvent->size <= Int_t(fEvent->headLen)) return 0;
 450
 451   eventHeaderStruct* subEvent = NULL;
 452   UChar_t* position = 0;
 453   UChar_t* end = 0;
 454   Int_t result = 0;
 455
 456   while (kTRUE) {
 457     // check for end of event data
 458     if (position >= ((UChar_t*)fEvent)+fEvent->size) return result;
 459     if ((fEvent->detectorId[2] & 0x8000) != 0x8000) {
 460       subEvent = fEvent;   // no super event
 461     } else if (subEvent) {
 462       subEvent = (eventHeaderStruct*) (((UChar_t*)subEvent) +
 463                                        subEvent->size);
 464     } else {
 465       subEvent = (eventHeaderStruct*) (((UChar_t*)fEvent) +
 466                                        fEvent->headLen);
 467     }
 468
 469     // check the magic word of the sub event
 470     if (subEvent->magic != EVENT_MAGIC_NUMBER) {
 471       result |= kErrMagic;
 472       return result;
 473     }
 474
 475     position = ((UChar_t*)subEvent) + subEvent->headLen;
 476     end = ((UChar_t*)subEvent) + subEvent->size;
 477
 478     // continue with the next sub event if no data left in the payload
 479     if (position >= end) continue;
 480
 481     if (fRequireHeader) {
 482       // check that there are enough bytes left for the data header
 483       if (position + sizeof(AliRawDataHeader) > end) {
 484         result |= kErrNoDataHeader;
 485         position = end;
 486         continue;
 487       }
 488
 489       // check consistency of data size in the data header and in the sub event
 490       AliRawDataHeader* header = (AliRawDataHeader*) position;
 491       if ((position + header->fSize) != end) {
 492         if (header->fSize != 0xFFFFFFFF)
 493           Warning("ReadHeader",
 494                   "raw data size found in the header is wrong (%d != %d)! Using the equipment size instead !",
 495                   header->fSize, end - position);
 496         header->fSize = end - position;
 497         result |= kErrSize;
 498       }
 499     }
 500     position = end;
 501   };
 502
 503   return 0;
 504 }