check of data consistency
[u/mrichter/AliRoot.git] / RAW / AliRawReaderDate.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 a class for reading a raw data from a date event and providing
19 // information about digits
20 //
21 ///////////////////////////////////////////////////////////////////////////////
22
23 #include "AliRawReaderDate.h"
24 #ifdef ALI_DATE
25 #include "event.h"
26 #endif
27
28 ClassImp(AliRawReaderDate)
29
30
31 AliRawReaderDate::AliRawReaderDate(
32 #ifdef ALI_DATE
33                                    void* event
34 #else
35                                    void* /* event */
36 #endif
37 )
38 {
39 // create an object to read digits from the given date event
40
41 #ifdef ALI_DATE
42   fEvent = (eventHeaderStruct*) event;
43   fSubEvent = NULL;
44   fPosition = fEnd = NULL;
45 #else
46   Fatal("AliRawReaderDate", "this class was compiled without DATE");
47 #endif
48 }
49
50 AliRawReaderDate::AliRawReaderDate(const AliRawReaderDate& rawReader) :
51   AliRawReader(rawReader)
52 {
53 // copy constructor
54
55   fEvent = rawReader.fEvent;
56   fSubEvent = rawReader.fSubEvent;
57   fPosition = rawReader.fPosition;
58   fEnd = rawReader.fEnd;
59 }
60
61 AliRawReaderDate& AliRawReaderDate::operator = (const AliRawReaderDate& 
62                                                 rawReader)
63 {
64 // assignment operator
65
66   this->~AliRawReaderDate();
67   new(this) AliRawReaderDate(rawReader);
68   return *this;
69 }
70
71
72 UInt_t AliRawReaderDate::GetType() const
73 {
74 // get the type from the event header
75
76 #ifdef ALI_DATE
77   if (!fEvent) return 0;
78   return fEvent->eventType;
79 #else
80   return 0;
81 #endif
82 }
83
84 UInt_t AliRawReaderDate::GetRunNumber() const
85 {
86 // get the run number from the event header
87
88 #ifdef ALI_DATE
89   if (!fEvent) return 0;
90   return fEvent->eventRunNb;
91 #else
92   return 0;
93 #endif
94 }
95
96 const UInt_t* AliRawReaderDate::GetEventId() const
97 {
98 // get the event id from the event header
99
100 #ifdef ALI_DATE
101   if (!fEvent) return NULL;
102   return fEvent->eventId;
103 #else
104   return NULL;
105 #endif
106 }
107
108 const UInt_t* AliRawReaderDate::GetTriggerPattern() const
109 {
110 // get the trigger pattern from the event header
111
112 #ifdef ALI_DATE
113   if (!fEvent) return NULL;
114   return fEvent->eventTriggerPattern;
115 #else
116   return NULL;
117 #endif
118 }
119
120 const UInt_t* AliRawReaderDate::GetDetectorPattern() const
121 {
122 // get the detector pattern from the event header
123
124 #ifdef ALI_DATE
125   if (!fEvent) return NULL;
126   return fEvent->eventDetectorPattern;
127 #else
128   return NULL;
129 #endif
130 }
131
132 const UInt_t* AliRawReaderDate::GetAttributes() const
133 {
134 // get the type attributes from the event header
135
136 #ifdef ALI_DATE
137   if (!fEvent) return NULL;
138   return fEvent->eventTypeAttribute;
139 #else
140   return NULL;
141 #endif
142 }
143
144 UInt_t AliRawReaderDate::GetGDCId() const
145 {
146 // get the GDC Id from the event header
147
148 #ifdef ALI_DATE
149   if (!fEvent) return 0;
150   return fEvent->eventGdcId;
151 #else
152   return 0;
153 #endif
154 }
155
156
157 Bool_t AliRawReaderDate::ReadMiniHeader()
158 {
159 // read a mini header at the current position
160 // returns kFALSE if the mini header could not be read
161
162   fErrorCode = 0;
163
164 #ifdef ALI_DATE
165   if (!fEvent) return kFALSE;
166   // check whether there are sub events
167   if (fEvent->eventSize <= fEvent->eventHeadSize) return kFALSE;
168
169   do {
170     // skip payload (if event was not selected)
171     if (fCount > 0) fPosition += fCount;
172
173     // get the first or the next sub event if at the end of a sub event
174     if (!fSubEvent || (fPosition >= fEnd)) {
175
176       // check for end of event data
177       if (fPosition >= ((UChar_t*)fEvent)+fEvent->eventSize) return kFALSE;
178       if (fSubEvent) {
179         fSubEvent = (eventHeaderStruct*) (((UChar_t*)fSubEvent) + 
180                                           fSubEvent->eventSize);
181       } else {
182         fSubEvent = (eventHeaderStruct*) (((UChar_t*)fEvent) + 
183                                           fEvent->eventHeadSize);
184       }
185
186       // check the magic word of the sub event
187       if (fSubEvent->eventMagic != EVENT_MAGIC_NUMBER) {
188         Error("ReadMiniHeader", "wrong magic number in sub event!\n"
189               " run: %d  event: %d %d  LDC: %d  GDC: %d\n", 
190               fSubEvent->eventRunNb, 
191               fSubEvent->eventId[0], fSubEvent->eventId[1],
192               fSubEvent->eventLdcId, fSubEvent->eventGdcId);
193         fErrorCode = kErrMagic;
194         return kFALSE;
195       }
196
197       fCount = 0;
198       fPosition = ((UChar_t*)fSubEvent) + fSubEvent->eventHeadSize + 
199         sizeof(equipmentHeaderStruct);
200       fEnd = ((UChar_t*)fSubEvent) + fSubEvent->eventSize;
201     }
202
203     // continue with the next sub event if no data left in the payload
204     if (fPosition >= fEnd) continue;
205
206     // check that there are enough bytes left for the mini header
207     if (fPosition + sizeof(AliMiniHeader) > fEnd) {
208       Error("ReadMiniHeader", "could not read mini header data!");
209       Warning("ReadMiniHeader", "skipping %d bytes\n"
210               " run: %d  event: %d %d  LDC: %d  GDC: %d\n", 
211               fEnd - fPosition, fSubEvent->eventRunNb, 
212               fSubEvent->eventId[0], fSubEvent->eventId[1],
213               fSubEvent->eventLdcId, fSubEvent->eventGdcId);
214       fCount = 0;
215       fPosition = fEnd;
216       fErrorCode = kErrNoMiniHeader;
217       continue;
218     }
219
220     // "read" and check the mini header
221     fMiniHeader = (AliMiniHeader*) fPosition;
222     fPosition += sizeof(AliMiniHeader);
223     if (!CheckMiniHeader()) {
224       Error("ReadMiniHeader", "wrong magic word in mini header!");
225       Warning("ReadMiniHeader", "skipping %d bytes\n"
226               " run: %d  event: %d %d  LDC: %d  GDC: %d\n", 
227               fEnd - fPosition, fSubEvent->eventRunNb, 
228               fSubEvent->eventId[0], fSubEvent->eventId[1],
229               fSubEvent->eventLdcId, fSubEvent->eventGdcId);
230       fCount = 0;
231       fPosition = fEnd;
232       fErrorCode = kErrMiniMagic;
233       continue;
234     }
235     fCount = fMiniHeader->fSize;
236
237     // check consistency of data size in the mini header and in the sub event
238     if (fPosition + fCount > fEnd) {
239       Error("ReadMiniHeader", "size in mini header exceeds event size!");
240       Warning("ReadMiniHeader", "skipping %d bytes\n"
241               " run: %d  event: %d %d  LDC: %d  GDC: %d\n", 
242               fEnd - fPosition, fSubEvent->eventRunNb, 
243               fSubEvent->eventId[0], fSubEvent->eventId[1],
244               fSubEvent->eventLdcId, fSubEvent->eventGdcId);
245       fCount = 0;
246       fPosition = fEnd;
247       fErrorCode = kErrSize;
248       continue;
249     }
250
251   } while (!IsSelected());
252
253   return kTRUE;
254 #else
255   return kFALSE;
256 #endif
257 }
258
259 Bool_t AliRawReaderDate::ReadNextData(UChar_t*& data)
260 {
261 // reads the next payload at the current position
262 // returns kFALSE if the data could not be read
263
264   fErrorCode = 0;
265   while (fCount == 0) {
266     if (!ReadMiniHeader()) return kFALSE;
267   }
268   data = fPosition;
269   fPosition += fCount;  
270   fCount = 0;
271   return kTRUE;
272 }
273
274 Bool_t AliRawReaderDate::ReadNext(UChar_t* data, Int_t size)
275 {
276 // reads the next block of data at the current position
277 // returns kFALSE if the data could not be read
278
279   fErrorCode = 0;
280   if (fPosition + size > fEnd) {
281     Error("ReadNext", "could not read data!");
282     fErrorCode = kErrOutOfBounds;
283     return kFALSE;
284   }
285   memcpy(data, fPosition, size);
286   fPosition += size;
287   fCount -= size;
288   return kTRUE;
289 }
290
291
292 Bool_t AliRawReaderDate::Reset()
293 {
294 // reset the current position to the beginning of the event
295
296 #ifdef ALI_DATE
297   fSubEvent = NULL;
298 #endif
299   fCount = 0;
300   fPosition = fEnd = NULL;
301   return kTRUE;
302 }
303
304
305 Int_t AliRawReaderDate::CheckData() const
306 {
307 // check the consistency of the data
308
309 #ifdef ALI_DATE
310   if (!fEvent) return 0;
311   // check whether there are sub events
312   if (fEvent->eventSize <= fEvent->eventHeadSize) return 0;
313
314   eventHeaderStruct* subEvent = NULL;
315   UChar_t* position = 0;
316   UChar_t* end = 0;
317
318   while (kTRUE) {
319     // get the first or the next sub event if at the end of a sub event
320     if (!subEvent || (position >= end)) {
321
322       // check for end of event data
323       if (position >= ((UChar_t*)fEvent)+fEvent->eventSize) return 0;
324       if (subEvent) {
325         subEvent = (eventHeaderStruct*) (((UChar_t*)subEvent) + 
326                                          subEvent->eventSize);
327       } else {
328         subEvent = (eventHeaderStruct*) (((UChar_t*)fEvent) + 
329                                          fEvent->eventHeadSize);
330       }
331
332       // check the magic word of the sub event
333       if (subEvent->eventMagic != EVENT_MAGIC_NUMBER) return kErrMagic;
334
335       position = ((UChar_t*)subEvent) + subEvent->eventHeadSize + 
336         sizeof(equipmentHeaderStruct);
337       end = ((UChar_t*)subEvent) + subEvent->eventSize;
338     }
339
340     // continue with the next sub event if no data left in the payload
341     if (position >= end) continue;
342
343     // check that there are enough bytes left for the mini header
344     if (position + sizeof(AliMiniHeader) > end) return kErrNoMiniHeader;
345
346     // "read" and check the mini header
347     AliMiniHeader* miniHeader = (AliMiniHeader*) position;
348     position += sizeof(AliMiniHeader);
349     if (!CheckMiniHeader(miniHeader)) return kErrMiniMagic;
350
351     // check consistency of data size in the mini header and in the sub event
352     if (position + miniHeader->fSize > end) return kErrSize;
353     position += miniHeader->fSize;
354   };
355
356 #endif
357   return 0;
358 }