Adding support for raw data events without subevent header
[u/mrichter/AliRoot.git] / RAW / AliRawReaderRoot.cxx
CommitLineData
04fa961a 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
bea6b2a4 16/* $Id$ */
17
04fa961a 18///////////////////////////////////////////////////////////////////////////////
bea6b2a4 19///
20/// This is a class for reading raw data from a root file.
21///
22/// The root file is expected to contain a tree of name "RAW" with
23/// a branch of name "rawevent" which contains objects of type
24/// AliRawEvent.
25///
26/// The file name and the event number are arguments of the constructor
27/// of AliRawReaderRoot.
28///
04fa961a 29///////////////////////////////////////////////////////////////////////////////
30
a197a4ce 31#include <TFile.h>
32#include <TTree.h>
04fa961a 33#include "AliRawReaderRoot.h"
42d20574 34#include "AliRawEvent.h"
a197a4ce 35#include "AliRawEventHeader.h"
94d918a7 36#include "AliRawEquipment.h"
a197a4ce 37#include "AliRawEquipmentHeader.h"
38#include "AliRawData.h"
04fa961a 39
40
41ClassImp(AliRawReaderRoot)
42
43
dd9a70fe 44AliRawReaderRoot::AliRawReaderRoot(const char* fileName, Int_t eventNumber) :
45 fFile(NULL),
46 fBranch(NULL),
47 fEventIndex(eventNumber),
48 fEvent(NULL),
49 fSubEventIndex(0),
50 fSubEvent(NULL),
94d918a7 51 fEquipmentIndex(0),
52 fEquipment(NULL),
dd9a70fe 53 fRawData(NULL),
54 fPosition(NULL),
55 fEnd(NULL)
04fa961a 56{
57// create an object to read digits from the given input file for the
58// event with the given number
59
03c6d9a3 60 TDirectory* dir = gDirectory;
04fa961a 61 fFile = TFile::Open(fileName);
03c6d9a3 62 dir->cd();
04fa961a 63 if (!fFile || !fFile->IsOpen()) {
64 Error("AliRawReaderRoot", "could not open file %s", fileName);
65 return;
66 }
67 TTree* tree = (TTree*) fFile->Get("RAW");
68 if (!tree) {
69 Error("AliRawReaderRoot", "no raw data tree found");
70 return;
71 }
dd9a70fe 72 fBranch = tree->GetBranch("rawevent");
73 if (!fBranch) {
04fa961a 74 Error("AliRawReaderRoot", "no raw data branch found");
75 return;
76 }
77
78 fEvent = new AliRawEvent;
dd9a70fe 79 fBranch->SetAddress(&fEvent);
80 if (fEventIndex >= 0) {
81 if (fBranch->GetEntry(fEventIndex) <= 0) {
82 Error("AliRawReaderRoot", "no event with number %d found", fEventIndex);
83 return;
84 }
04fa961a 85 }
04fa961a 86}
87
dd9a70fe 88AliRawReaderRoot::AliRawReaderRoot(AliRawEvent* event) :
89 fFile(NULL),
90 fBranch(NULL),
91 fEventIndex(-1),
92 fEvent(event),
93 fSubEventIndex(0),
94 fSubEvent(NULL),
94d918a7 95 fEquipmentIndex(0),
96 fEquipment(NULL),
dd9a70fe 97 fRawData(NULL),
98 fPosition(NULL),
99 fEnd(NULL)
04fa961a 100{
101// create an object to read digits from the given raw event
102
04fa961a 103}
104
42d20574 105AliRawReaderRoot::AliRawReaderRoot(const AliRawReaderRoot& rawReader) :
dd9a70fe 106 AliRawReader(rawReader),
107 fFile(NULL),
108 fBranch(NULL),
109 fEventIndex(rawReader.fEventIndex),
110 fEvent(NULL),
111 fSubEventIndex(rawReader.fSubEventIndex),
112 fSubEvent(NULL),
94d918a7 113 fEquipmentIndex(rawReader.fEquipmentIndex),
114 fEquipment(NULL),
dd9a70fe 115 fRawData(NULL),
116 fPosition(NULL),
117 fEnd(NULL)
42d20574 118{
119// copy constructor
120
dd9a70fe 121 if (rawReader.fFile) {
122 TDirectory* dir = gDirectory;
123 fFile = TFile::Open(rawReader.fFile->GetName());
124 dir->cd();
125 if (!fFile || !fFile->IsOpen()) {
126 Error("AliRawReaderRoot", "could not open file %s",
127 rawReader.fFile->GetName());
128 return;
129 }
130 TTree* tree = (TTree*) fFile->Get("RAW");
131 if (!tree) {
132 Error("AliRawReaderRoot", "no raw data tree found");
133 return;
134 }
135 fBranch = tree->GetBranch("rawevent");
136 if (!fBranch) {
137 Error("AliRawReaderRoot", "no raw data branch found");
138 return;
139 }
140
141 fEvent = new AliRawEvent;
142 fBranch->SetAddress(&fEvent);
143 if (fEventIndex >= 0) {
144 if (fBranch->GetEntry(fEventIndex) <= 0) {
145 Error("AliRawReaderRoot", "no event with number %d found",
146 fEventIndex);
147 return;
148 }
149 }
150 } else {
151 fEvent = rawReader.fEvent;
152 }
153
154 if (fSubEventIndex > 0) {
155 fSubEvent = fEvent->GetSubEvent(fSubEventIndex-1);
94d918a7 156 fEquipment = fSubEvent->GetEquipment(fEquipmentIndex);
157 fRawData = fEquipment->GetRawData();
dd9a70fe 158 fCount = 0;
159 fHeader = (AliRawDataHeader*) ((UChar_t*) fRawData->GetBuffer() +
160 ((UChar_t*) rawReader.fHeader -
161 (UChar_t*) rawReader.fRawData->GetBuffer()));
162 fPosition = (UChar_t*) fRawData->GetBuffer() +
163 (rawReader.fPosition - (UChar_t*) rawReader.fRawData->GetBuffer());
164 fEnd = ((UChar_t*) fRawData->GetBuffer()) + fRawData->GetSize();
165 }
42d20574 166}
167
168AliRawReaderRoot& AliRawReaderRoot::operator = (const AliRawReaderRoot&
169 rawReader)
170{
171// assignment operator
172
173 this->~AliRawReaderRoot();
174 new(this) AliRawReaderRoot(rawReader);
175 return *this;
176}
177
04fa961a 178AliRawReaderRoot::~AliRawReaderRoot()
179{
180// delete objects and close root file
181
182 if (fFile) {
183 if (fEvent) delete fEvent;
184 fFile->Close();
185 delete fFile;
186 }
187}
188
189
42d20574 190UInt_t AliRawReaderRoot::GetType() const
04fa961a 191{
192// get the type from the event header
193
194 if (!fEvent) return 0;
195 return fEvent->GetHeader()->GetType();
196}
197
42d20574 198UInt_t AliRawReaderRoot::GetRunNumber() const
04fa961a 199{
200// get the run number from the event header
201
202 if (!fEvent) return 0;
203 return fEvent->GetHeader()->GetRunNumber();
204}
205
42d20574 206const UInt_t* AliRawReaderRoot::GetEventId() const
04fa961a 207{
208// get the event id from the event header
209
210 if (!fEvent) return NULL;
211 return fEvent->GetHeader()->GetId();
212}
213
42d20574 214const UInt_t* AliRawReaderRoot::GetTriggerPattern() const
04fa961a 215{
216// get the trigger pattern from the event header
217
218 if (!fEvent) return NULL;
219 return fEvent->GetHeader()->GetTriggerPattern();
220}
221
42d20574 222const UInt_t* AliRawReaderRoot::GetDetectorPattern() const
04fa961a 223{
224// get the detector pattern from the event header
225
226 if (!fEvent) return NULL;
227 return fEvent->GetHeader()->GetDetectorPattern();
228}
229
42d20574 230const UInt_t* AliRawReaderRoot::GetAttributes() const
04fa961a 231{
232// get the type attributes from the event header
233
234 if (!fEvent) return NULL;
235 return fEvent->GetHeader()->GetTypeAttribute();
236}
237
e94ad92c 238const UInt_t* AliRawReaderRoot::GetSubEventAttributes() const
239{
240// get the type attributes from the sub event header
241
242 if (!fSubEvent) return NULL;
243 return fSubEvent->GetHeader()->GetTypeAttribute();
244}
245
c946ab02 246UInt_t AliRawReaderRoot::GetLDCId() const
247{
248// get the LDC Id from the event header
249
94d918a7 250 if (!fEvent || !fSubEvent) return 0;
251 return fSubEvent->GetHeader()->GetLDCId();
c946ab02 252}
253
42d20574 254UInt_t AliRawReaderRoot::GetGDCId() const
04fa961a 255{
256// get the GDC Id from the event header
257
258 if (!fEvent) return 0;
259 return fEvent->GetHeader()->GetGDCId();
260}
261
262
c946ab02 263Int_t AliRawReaderRoot::GetEquipmentSize() const
264{
265// get the size of the equipment
266
94d918a7 267 if (!fEvent || !fEquipment || !fEquipment->GetEquipmentHeader()) return 0;
268 return fEquipment->GetEquipmentHeader()->GetEquipmentSize();
c946ab02 269}
270
271Int_t AliRawReaderRoot::GetEquipmentType() const
272{
273// get the type from the equipment header
274
94d918a7 275 if (!fEvent || !fEquipment || !fEquipment->GetEquipmentHeader()) return -1;
276 return fEquipment->GetEquipmentHeader()->GetEquipmentType();
c946ab02 277}
278
279Int_t AliRawReaderRoot::GetEquipmentId() const
280{
281// get the ID from the equipment header
282
94d918a7 283 if (!fEvent || !fEquipment || !fEquipment->GetEquipmentHeader()) return -1;
284 return fEquipment->GetEquipmentHeader()->GetId();
c946ab02 285}
286
287const UInt_t* AliRawReaderRoot::GetEquipmentAttributes() const
288{
289// get the attributes from the equipment header
290
94d918a7 291 if (!fEvent || !fEquipment || !fEquipment->GetEquipmentHeader()) return NULL;
292 return fEquipment->GetEquipmentHeader()->GetTypeAttribute();
c946ab02 293}
294
295Int_t AliRawReaderRoot::GetEquipmentElementSize() const
296{
297// get the basic element size from the equipment header
298
94d918a7 299 if (!fEvent || !fEquipment || !fEquipment->GetEquipmentHeader()) return 0;
300 return fEquipment->GetEquipmentHeader()->GetBasicSizeType();
c946ab02 301}
302
303
304Bool_t AliRawReaderRoot::ReadHeader()
04fa961a 305{
39f9963f 306// read a data header at the current position
307// returns kFALSE if the data header could not be read
04fa961a 308
b4857df7 309 fErrorCode = 0;
04fa961a 310 if (!fEvent) return kFALSE;
b4857df7 311
04fa961a 312 do {
b4857df7 313 // skip payload (if event was not selected)
314 if (fCount > 0) fPosition += fCount;
315
94d918a7 316 // get the first or the next equipment if at the end of an equipment
317 if (!fEquipment || (fPosition >= fEnd)) {
b4857df7 318
94d918a7 319 // get the first or the next sub event if at the end of a sub event
320 if (!fSubEvent || (fEquipmentIndex >= fSubEvent->GetNEquipments())) {
b4857df7 321
94d918a7 322 // check for end of event data
323 if (fSubEventIndex >= fEvent->GetNSubEvents()) return kFALSE;
324 fSubEvent = fEvent->GetSubEvent(fSubEventIndex++);
325
326 // check the magic word of the sub event
327 if (!fSubEvent->GetHeader()->IsValid()) {
328 Error("ReadHeader", "wrong magic number in sub event!");
329 fSubEvent->GetHeader()->Dump();
330 fErrorCode = kErrMagic;
331 return kFALSE;
332 }
333
334 fEquipmentIndex = 0;
335 fEquipment = NULL;
336 fRawData = NULL;
b4857df7 337 }
338
94d918a7 339 // get the next equipment and raw data
04fa961a 340 fCount = 0;
94d918a7 341 fEquipment = fSubEvent->GetEquipment(fEquipmentIndex++);
342 if (!fEquipment) continue;
343 fRawData = fEquipment->GetRawData();
344 if (!fRawData) {
345 fPosition = fEnd;
346 continue;
347 }
04fa961a 348 fPosition = (UChar_t*) fRawData->GetBuffer();
349 fEnd = ((UChar_t*) fRawData->GetBuffer()) + fRawData->GetSize();
350 }
b4857df7 351
94d918a7 352 // continue with the next equipment if no data left in the payload
b4857df7 353 if (fPosition >= fEnd) continue;
354
18882b3b 355 if (fRequireHeader) {
356 // check that there are enough bytes left for the data header
357 if (fPosition + sizeof(AliRawDataHeader) > fEnd) {
358 Error("ReadHeader", "could not read data header!");
359 Warning("ReadHeader", "skipping %d bytes", fEnd - fPosition);
360 fEquipment->GetEquipmentHeader()->Dump();
361 fCount = 0;
362 fPosition = fEnd;
363 fErrorCode = kErrNoDataHeader;
364 continue;
365 }
366
367 // "read" the data header
368 fHeader = (AliRawDataHeader*) fPosition;
369 fPosition += sizeof(AliRawDataHeader);
04fa961a 370 }
b4857df7 371
39f9963f 372 if (fHeader->fSize != 0xFFFFFFFF) {
373 fCount = fHeader->fSize - sizeof(AliRawDataHeader);
374 } else {
375 fCount = fEnd - fPosition;
72dd1d4f 376 }
b4857df7 377
39f9963f 378 // check consistency of data size in the header and in the sub event
b4857df7 379 if (fPosition + fCount > fEnd) {
39f9963f 380 Error("ReadHeader", "size in data header exceeds event size!");
c946ab02 381 Warning("ReadHeader", "skipping %d bytes", fEnd - fPosition);
94d918a7 382 fEquipment->GetEquipmentHeader()->Dump();
03c6d9a3 383 fCount = 0;
384 fPosition = fEnd;
b4857df7 385 fErrorCode = kErrSize;
03c6d9a3 386 continue;
04fa961a 387 }
b4857df7 388
04fa961a 389 } while (!IsSelected());
b4857df7 390
04fa961a 391 return kTRUE;
392}
393
394Bool_t AliRawReaderRoot::ReadNextData(UChar_t*& data)
395{
396// reads the next payload at the current position
397// returns kFALSE if the data could not be read
398
b4857df7 399 fErrorCode = 0;
04fa961a 400 while (fCount == 0) {
c946ab02 401 if (!ReadHeader()) return kFALSE;
04fa961a 402 }
403 data = fPosition;
404 fPosition += fCount;
405 fCount = 0;
406 return kTRUE;
407}
408
409Bool_t AliRawReaderRoot::ReadNext(UChar_t* data, Int_t size)
410{
411// reads the next block of data at the current position
412// returns kFALSE if the data could not be read
413
b4857df7 414 fErrorCode = 0;
04fa961a 415 if (fPosition + size > fEnd) {
416 Error("ReadNext", "could not read data!");
b4857df7 417 fErrorCode = kErrOutOfBounds;
04fa961a 418 return kFALSE;
419 }
420 memcpy(data, fPosition, size);
421 fPosition += size;
422 fCount -= size;
423 return kTRUE;
424}
425
426
427Bool_t AliRawReaderRoot::Reset()
428{
429// reset the current position to the beginning of the event
430
431 fSubEventIndex = 0;
432 fSubEvent = NULL;
94d918a7 433 fEquipmentIndex = 0;
434 fEquipment = NULL;
04fa961a 435 fRawData = NULL;
39f9963f 436 fHeader = NULL;
04fa961a 437
438 fCount = 0;
439 fPosition = fEnd = NULL;
440 return kTRUE;
441}
442
b4857df7 443
dd9a70fe 444Bool_t AliRawReaderRoot::NextEvent()
445{
446// go to the next event in the root file
447
448 if (!fFile) return kFALSE;
449
450 do {
451 if (fBranch->GetEntry(fEventIndex+1) <= 0) {
452 delete fEvent;
453 fEvent = new AliRawEvent;
454 fBranch->SetAddress(&fEvent);
455 return kFALSE;
456 }
457 fEventIndex++;
458 } while (!IsEventSelected());
459 return Reset();
460}
461
462Bool_t AliRawReaderRoot::RewindEvents()
463{
464// go back to the beginning of the root file
465
466 if (!fFile) return kFALSE;
467
468 fEventIndex = -1;
469 delete fEvent;
470 fEvent = new AliRawEvent;
471 fBranch->SetAddress(&fEvent);
472 return Reset();
473}
474
475
b4857df7 476Int_t AliRawReaderRoot::CheckData() const
477{
478// check the consistency of the data
479
480 if (!fEvent) return 0;
481
482 AliRawEvent* subEvent = NULL;
483 Int_t subEventIndex = 0;
94d918a7 484 AliRawEquipment* equipment = NULL;
485 Int_t equipmentIndex = 0;
b4857df7 486 UChar_t* position = 0;
487 UChar_t* end = 0;
be50fca2 488 Int_t result = 0;
b4857df7 489
490 while (kTRUE) {
94d918a7 491 // get the first or the next sub event if at the end of an equipment
492 if (!subEvent || (equipmentIndex >= subEvent->GetNEquipments())) {
b4857df7 493
494 // check for end of event data
be50fca2 495 if (subEventIndex >= fEvent->GetNSubEvents()) return result;
b4857df7 496 subEvent = fEvent->GetSubEvent(subEventIndex++);
497
498 // check the magic word of the sub event
be50fca2 499 if (!fSubEvent->GetHeader()->IsValid()) {
500 result |= kErrMagic;
501 return result;
502 }
b4857df7 503
94d918a7 504 equipmentIndex = 0;
b4857df7 505 }
506
94d918a7 507 // get the next equipment and raw data
508 equipment = subEvent->GetEquipment(equipmentIndex++);
509 if (!equipment) continue;
510 AliRawData* rawData = equipment->GetRawData();
511 if (!rawData) continue;
512 position = (UChar_t*) rawData->GetBuffer();
513 end = ((UChar_t*) rawData->GetBuffer()) + rawData->GetSize();
514
b4857df7 515 // continue with the next sub event if no data left in the payload
516 if (position >= end) continue;
517
18882b3b 518 if (fRequireHeader) {
39f9963f 519 // check that there are enough bytes left for the data header
18882b3b 520 if (position + sizeof(AliRawDataHeader) > end) {
521 result |= kErrNoDataHeader;
522 continue;
523 }
b4857df7 524
18882b3b 525 // check consistency of data size in the header and in the equipment
526 AliRawDataHeader* header = (AliRawDataHeader*) position;
527 if (header->fSize != 0xFFFFFFFF) {
528 if (position + header->fSize > end) {
529 result |= kErrSize;
530 }
39f9963f 531 }
be50fca2 532 }
b4857df7 533 };
fd0de2e2 534
535 return result;
b4857df7 536}