RAW/AliRawReader.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 ///////////////////////////////////////////////////////////////////////////////
  17 //
  18 // This is the base class for reading raw data and providing
  19 // information about digits
  20 //
  21 // The derived classes, which operate on concrete raw data formats,
  22 // should implement
  23 // - ReadMiniHeader to read the next mini header
  24 // - ReadNextData to read the next raw data block (=1 DDL)
  25 // - ReadNext to read a given number of bytes
  26 // - several getters like GetType
  27 //
  28 // Sequential access to the raw data is provided by the methods
  29 // ReadMiniHeader, ReadNextData, ReadNextInt, ReadNextShort, ReadNextChar
  30 //
  31 // If only data from a specific detector (and a given range of DDL numbers)
  32 // should be read, this can be achieved by the Select method.
  33 // Several getter provide information about the current event and the
  34 // current type of raw data.
  35 //
  36 ///////////////////////////////////////////////////////////////////////////////
  37
  38 #include "AliRawReader.h"
  39
  40
  41 ClassImp(AliRawReader)
  42
  43
  44 AliRawReader::AliRawReader()
  45 {
  46 // default constructor: initialize data members
  47
  48   fMiniHeader = NULL;
  49   fCount = 0;
  50
  51   fSelectDetectorID = -1;
  52   fSelectMinDDLID = -1;
  53   fSelectMaxDDLID = -1;
  54
  55   fErrorCode = 0;
  56 }
  57
  58 AliRawReader::AliRawReader(const AliRawReader& rawReader) :
  59   TObject(rawReader)
  60 {
  61 // copy constructor
  62
  63   fMiniHeader = rawReader.fMiniHeader;
  64   fCount = rawReader.fCount;
  65
  66   fSelectDetectorID = rawReader.fSelectDetectorID;
  67   fSelectMinDDLID = rawReader.fSelectMinDDLID;
  68   fSelectMaxDDLID = rawReader.fSelectMaxDDLID;
  69
  70   fErrorCode = 0;
  71 }
  72
  73 AliRawReader& AliRawReader::operator = (const AliRawReader& rawReader)
  74 {
  75 // assignment operator
  76
  77   fMiniHeader = rawReader.fMiniHeader;
  78   fCount = rawReader.fCount;
  79
  80   fSelectDetectorID = rawReader.fSelectDetectorID;
  81   fSelectMinDDLID = rawReader.fSelectMinDDLID;
  82   fSelectMaxDDLID = rawReader.fSelectMaxDDLID;
  83
  84   fErrorCode = rawReader.fErrorCode;
  85
  86   return *this;
  87 }
  88
  89
  90 void AliRawReader::Select(Int_t detectorID, Int_t minDDLID, Int_t maxDDLID)
  91 {
  92 // read only data of the detector with the given ID and in the given
  93 // range of DDLs (minDDLID <= DDLID < maxDDLID).
  94 // no selection is applied if a value < 0 is used.
  95
  96   fSelectDetectorID = detectorID;
  97   fSelectMinDDLID = minDDLID;
  98   fSelectMaxDDLID = maxDDLID;
  99 }
 100
 101 Bool_t AliRawReader::IsSelected() const
 102 {
 103 // apply the selection (if any)
 104
 105   if (fSelectDetectorID >= 0) {
 106     if (fMiniHeader->fDetectorID != fSelectDetectorID) return kFALSE;
 107     if ((fSelectMinDDLID >= 0) && (fMiniHeader->fDDLID < fSelectMinDDLID))
 108       return kFALSE;
 109     if ((fSelectMaxDDLID >= 0) && (fMiniHeader->fDDLID >= fSelectMaxDDLID))
 110       return kFALSE;
 111   }
 112   return kTRUE;
 113 }
 114
 115
 116 Bool_t AliRawReader::CheckMiniHeader(AliMiniHeader* miniHeader) const
 117 {
 118 // check the magic number of the mini header
 119
 120   if (!miniHeader) miniHeader = fMiniHeader;
 121   if ((miniHeader->fMagicWord[2] != 0x12) ||
 122       (miniHeader->fMagicWord[1] != 0x34) ||
 123       (miniHeader->fMagicWord[0] != 0x56)) {
 124     return kFALSE;
 125   }
 126   return kTRUE;
 127 }
 128
 129 Bool_t AliRawReader::ReadNextInt(UInt_t& data)
 130 {
 131 // reads the next 4 bytes at the current position
 132 // returns kFALSE if the data could not be read
 133
 134   while (fCount == 0) {
 135     if (!ReadMiniHeader()) return kFALSE;
 136   }
 137   if (fCount < (Int_t) sizeof(data)) {
 138     Error("ReadNextInt",
 139           "too few data left (%d bytes) to read an UInt_t!", fCount);
 140     return kFALSE;
 141   }
 142   if (!ReadNext((UChar_t*) &data, sizeof(data))) {
 143     Error("ReadNextInt", "could not read data!");
 144     return kFALSE;
 145   }
 146   return kTRUE;
 147 }
 148
 149 Bool_t AliRawReader::ReadNextShort(UShort_t& data)
 150 {
 151 // reads the next 2 bytes at the current position
 152 // returns kFALSE if the data could not be read
 153
 154   while (fCount == 0) {
 155     if (!ReadMiniHeader()) return kFALSE;
 156   }
 157   if (fCount < (Int_t) sizeof(data)) {
 158     Error("ReadNextShort",
 159           "too few data left (%d bytes) to read an UShort_t!", fCount);
 160     return kFALSE;
 161   }
 162   if (!ReadNext((UChar_t*) &data, sizeof(data))) {
 163     Error("ReadNextShort", "could not read data!");
 164     return kFALSE;
 165   }
 166   return kTRUE;
 167 }
 168
 169 Bool_t AliRawReader::ReadNextChar(UChar_t& data)
 170 {
 171 // reads the next 1 byte at the current stream position
 172 // returns kFALSE if the data could not be read
 173
 174   while (fCount == 0) {
 175     if (!ReadMiniHeader()) return kFALSE;
 176   }
 177   if (!ReadNext((UChar_t*) &data, sizeof(data))) {
 178     Error("ReadNextChar", "could not read data!");
 179     return kFALSE;
 180   }
 181   return kTRUE;
 182 }
 183
 184
 185 Int_t AliRawReader::CheckData() const
 186 {
 187 // check the consistency of the data
 188 // derived classes should overwrite the default method which returns 0 (no err)
 189
 190   return 0;
 191 }
 192