check of data consistency
[u/mrichter/AliRoot.git] / 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