- Reset TProcessID count after each event
[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"
f2dc6b20 35#include "AliRawEventHeaderBase.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
1fb5b4a8 189const AliRawEventHeaderBase* AliRawReaderRoot::GetEventHeader() const
190{
191 // Get the even header
192 // Return NULL in case of failure
193 if (!fEvent) return NULL;
194 return fEvent->GetHeader();
195}
04fa961a 196
42d20574 197UInt_t AliRawReaderRoot::GetType() const
04fa961a 198{
199// get the type from the event header
200
201 if (!fEvent) return 0;
f2dc6b20 202 return fEvent->GetHeader()->Get("Type");
04fa961a 203}
204
42d20574 205UInt_t AliRawReaderRoot::GetRunNumber() const
04fa961a 206{
207// get the run number from the event header
208
209 if (!fEvent) return 0;
f2dc6b20 210 return fEvent->GetHeader()->Get("RunNb");
04fa961a 211}
212
42d20574 213const UInt_t* AliRawReaderRoot::GetEventId() const
04fa961a 214{
215// get the event id from the event header
216
217 if (!fEvent) return NULL;
f2dc6b20 218 return fEvent->GetHeader()->GetP("Id");
04fa961a 219}
220
42d20574 221const UInt_t* AliRawReaderRoot::GetTriggerPattern() const
04fa961a 222{
223// get the trigger pattern from the event header
224
225 if (!fEvent) return NULL;
f2dc6b20 226 return fEvent->GetHeader()->GetP("TriggerPattern");
04fa961a 227}
228
42d20574 229const UInt_t* AliRawReaderRoot::GetDetectorPattern() const
04fa961a 230{
231// get the detector pattern from the event header
232
233 if (!fEvent) return NULL;
f2dc6b20 234 return fEvent->GetHeader()->GetP("DetectorPattern");
04fa961a 235}
236
42d20574 237const UInt_t* AliRawReaderRoot::GetAttributes() const
04fa961a 238{
239// get the type attributes from the event header
240
241 if (!fEvent) return NULL;
f2dc6b20 242 return fEvent->GetHeader()->GetP("TypeAttribute");
04fa961a 243}
244
e94ad92c 245const UInt_t* AliRawReaderRoot::GetSubEventAttributes() const
246{
247// get the type attributes from the sub event header
248
249 if (!fSubEvent) return NULL;
f2dc6b20 250 return fSubEvent->GetHeader()->GetP("TypeAttribute");
e94ad92c 251}
252
c946ab02 253UInt_t AliRawReaderRoot::GetLDCId() const
254{
255// get the LDC Id from the event header
256
94d918a7 257 if (!fEvent || !fSubEvent) return 0;
f2dc6b20 258 return fSubEvent->GetHeader()->Get("LdcId");
c946ab02 259}
260
42d20574 261UInt_t AliRawReaderRoot::GetGDCId() const
04fa961a 262{
263// get the GDC Id from the event header
264
265 if (!fEvent) return 0;
f2dc6b20 266 return fEvent->GetHeader()->Get("GdcId");
04fa961a 267}
268
741c154c 269UInt_t AliRawReaderRoot::GetTimestamp() const
270{
271 if (!fEvent) return 0;
272 return fEvent->GetHeader()->Get("Timestamp");
273}
04fa961a 274
c946ab02 275Int_t AliRawReaderRoot::GetEquipmentSize() const
276{
277// get the size of the equipment
278
94d918a7 279 if (!fEvent || !fEquipment || !fEquipment->GetEquipmentHeader()) return 0;
280 return fEquipment->GetEquipmentHeader()->GetEquipmentSize();
c946ab02 281}
282
283Int_t AliRawReaderRoot::GetEquipmentType() const
284{
285// get the type from the equipment header
286
94d918a7 287 if (!fEvent || !fEquipment || !fEquipment->GetEquipmentHeader()) return -1;
288 return fEquipment->GetEquipmentHeader()->GetEquipmentType();
c946ab02 289}
290
291Int_t AliRawReaderRoot::GetEquipmentId() const
292{
293// get the ID from the equipment header
294
94d918a7 295 if (!fEvent || !fEquipment || !fEquipment->GetEquipmentHeader()) return -1;
296 return fEquipment->GetEquipmentHeader()->GetId();
c946ab02 297}
298
299const UInt_t* AliRawReaderRoot::GetEquipmentAttributes() const
300{
301// get the attributes from the equipment header
302
94d918a7 303 if (!fEvent || !fEquipment || !fEquipment->GetEquipmentHeader()) return NULL;
304 return fEquipment->GetEquipmentHeader()->GetTypeAttribute();
c946ab02 305}
306
307Int_t AliRawReaderRoot::GetEquipmentElementSize() const
308{
309// get the basic element size from the equipment header
310
94d918a7 311 if (!fEvent || !fEquipment || !fEquipment->GetEquipmentHeader()) return 0;
312 return fEquipment->GetEquipmentHeader()->GetBasicSizeType();
c946ab02 313}
314
299738b9 315Int_t AliRawReaderRoot::GetEquipmentHeaderSize() const
316{
317// get the size of the equipment header (28 bytes by default)
318
319 if (!fEvent || !fEquipment || !fEquipment->GetEquipmentHeader()) return 0;
320 return fEquipment->GetEquipmentHeader()->HeaderSize();
321}
322
edd06192 323// _________________________________________________________________________
edd06192 324void AliRawReaderRoot::SwapData(const void* inbuf, const void* outbuf, UInt_t size) {
325 // The method swaps the contents of the
326 // raw-data event header
91f76e9b 327 UInt_t intCount = (size+3)/sizeof(UInt_t);
edd06192 328
329 UInt_t* buf = (UInt_t*) inbuf; // temporary integers buffer
330 for (UInt_t i=0; i<intCount; i++, buf++) {
331 UInt_t value = SwapWord(*buf);
dae3f0d9 332 if (i==(intCount-1))
333 memcpy((UInt_t*)outbuf+i, &value, size%sizeof(UInt_t));
334 else
335 memcpy((UInt_t*)outbuf+i, &value, sizeof(UInt_t));
edd06192 336 }
337}
338// _________________________________________________________________________
c946ab02 339
340Bool_t AliRawReaderRoot::ReadHeader()
04fa961a 341{
39f9963f 342// read a data header at the current position
343// returns kFALSE if the data header could not be read
04fa961a 344
b4857df7 345 fErrorCode = 0;
04fa961a 346 if (!fEvent) return kFALSE;
b4857df7 347
04fa961a 348 do {
b4857df7 349 // skip payload (if event was not selected)
350 if (fCount > 0) fPosition += fCount;
351
94d918a7 352 // get the first or the next equipment if at the end of an equipment
353 if (!fEquipment || (fPosition >= fEnd)) {
b4857df7 354
94d918a7 355 // get the first or the next sub event if at the end of a sub event
356 if (!fSubEvent || (fEquipmentIndex >= fSubEvent->GetNEquipments())) {
b4857df7 357
94d918a7 358 // check for end of event data
359 if (fSubEventIndex >= fEvent->GetNSubEvents()) return kFALSE;
360 fSubEvent = fEvent->GetSubEvent(fSubEventIndex++);
361
362 // check the magic word of the sub event
363 if (!fSubEvent->GetHeader()->IsValid()) {
364 Error("ReadHeader", "wrong magic number in sub event!");
365 fSubEvent->GetHeader()->Dump();
366 fErrorCode = kErrMagic;
367 return kFALSE;
368 }
369
370 fEquipmentIndex = 0;
371 fEquipment = NULL;
372 fRawData = NULL;
b4857df7 373 }
374
94d918a7 375 // get the next equipment and raw data
04fa961a 376 fCount = 0;
94d918a7 377 fEquipment = fSubEvent->GetEquipment(fEquipmentIndex++);
378 if (!fEquipment) continue;
3d65cc80 379 if (!IsSelected()) {
380 fPosition = fEnd;
381 continue;
382 }
94d918a7 383 fRawData = fEquipment->GetRawData();
384 if (!fRawData) {
385 fPosition = fEnd;
386 continue;
387 }
04fa961a 388 fPosition = (UChar_t*) fRawData->GetBuffer();
389 fEnd = ((UChar_t*) fRawData->GetBuffer()) + fRawData->GetSize();
390 }
b4857df7 391
94d918a7 392 // continue with the next equipment if no data left in the payload
b4857df7 393 if (fPosition >= fEnd) continue;
394
18882b3b 395 if (fRequireHeader) {
396 // check that there are enough bytes left for the data header
397 if (fPosition + sizeof(AliRawDataHeader) > fEnd) {
398 Error("ReadHeader", "could not read data header!");
399 Warning("ReadHeader", "skipping %d bytes", fEnd - fPosition);
400 fEquipment->GetEquipmentHeader()->Dump();
401 fCount = 0;
402 fPosition = fEnd;
403 fErrorCode = kErrNoDataHeader;
404 continue;
405 }
406
407 // "read" the data header
408 fHeader = (AliRawDataHeader*) fPosition;
edd06192 409#ifndef R__BYTESWAP
410 SwapData((void*) fHeader, (void*) fHeaderSwapped, sizeof(AliRawDataHeader));
411 fHeader=fHeaderSwapped;
412#endif
299738b9 413 if ((fPosition + fHeader->fSize) != fEnd) {
806e573c 414 if (fHeader->fSize != 0xFFFFFFFF)
415 Warning("ReadHeader",
416 "Equipment %d : raw data size found in the header is wrong (%d != %d)! Using the equipment size instead !",
417 fEquipment->GetEquipmentHeader()->GetId(),fHeader->fSize, fEnd - fPosition);
299738b9 418 fHeader->fSize = fEnd - fPosition;
419 }
18882b3b 420 fPosition += sizeof(AliRawDataHeader);
04fa961a 421 }
b4857df7 422
7c726b91 423 if (fHeader && (fHeader->fSize != 0xFFFFFFFF)) {
39f9963f 424 fCount = fHeader->fSize - sizeof(AliRawDataHeader);
7c726b91 425
426 // check consistency of data size in the header and in the sub event
427 if (fPosition + fCount > fEnd) {
428 Error("ReadHeader", "size in data header exceeds event size!");
429 Warning("ReadHeader", "skipping %d bytes", fEnd - fPosition);
430 fEquipment->GetEquipmentHeader()->Dump();
431 fCount = 0;
432 fPosition = fEnd;
433 fErrorCode = kErrSize;
434 continue;
435 }
436
39f9963f 437 } else {
438 fCount = fEnd - fPosition;
72dd1d4f 439 }
b4857df7 440
04fa961a 441 } while (!IsSelected());
b4857df7 442
04fa961a 443 return kTRUE;
444}
445
446Bool_t AliRawReaderRoot::ReadNextData(UChar_t*& data)
447{
448// reads the next payload at the current position
449// returns kFALSE if the data could not be read
450
b4857df7 451 fErrorCode = 0;
04fa961a 452 while (fCount == 0) {
c946ab02 453 if (!ReadHeader()) return kFALSE;
04fa961a 454 }
455 data = fPosition;
456 fPosition += fCount;
457 fCount = 0;
458 return kTRUE;
459}
460
461Bool_t AliRawReaderRoot::ReadNext(UChar_t* data, Int_t size)
462{
463// reads the next block of data at the current position
464// returns kFALSE if the data could not be read
465
b4857df7 466 fErrorCode = 0;
04fa961a 467 if (fPosition + size > fEnd) {
468 Error("ReadNext", "could not read data!");
b4857df7 469 fErrorCode = kErrOutOfBounds;
04fa961a 470 return kFALSE;
471 }
472 memcpy(data, fPosition, size);
dae3f0d9 473
04fa961a 474 fPosition += size;
475 fCount -= size;
476 return kTRUE;
477}
478
479
480Bool_t AliRawReaderRoot::Reset()
481{
482// reset the current position to the beginning of the event
483
484 fSubEventIndex = 0;
485 fSubEvent = NULL;
94d918a7 486 fEquipmentIndex = 0;
487 fEquipment = NULL;
04fa961a 488 fRawData = NULL;
39f9963f 489 fHeader = NULL;
04fa961a 490
491 fCount = 0;
492 fPosition = fEnd = NULL;
493 return kTRUE;
494}
495
b4857df7 496
dd9a70fe 497Bool_t AliRawReaderRoot::NextEvent()
498{
499// go to the next event in the root file
500
2da4ef20 501 if (!fBranch) return kFALSE;
dd9a70fe 502
503 do {
d41ecdd0 504 delete fEvent;
505 fEvent = new AliRawEvent;
506 fBranch->SetAddress(&fEvent);
507 if (fBranch->GetEntry(fEventIndex+1) <= 0)
dd9a70fe 508 return kFALSE;
dd9a70fe 509 fEventIndex++;
510 } while (!IsEventSelected());
38cf12f3 511 fEventNumber++;
dd9a70fe 512 return Reset();
513}
514
515Bool_t AliRawReaderRoot::RewindEvents()
516{
517// go back to the beginning of the root file
518
2da4ef20 519 if (!fBranch) return kFALSE;
dd9a70fe 520
521 fEventIndex = -1;
522 delete fEvent;
523 fEvent = new AliRawEvent;
524 fBranch->SetAddress(&fEvent);
38cf12f3 525 fEventNumber = -1;
dd9a70fe 526 return Reset();
527}
528
529
b4857df7 530Int_t AliRawReaderRoot::CheckData() const
531{
532// check the consistency of the data
533
534 if (!fEvent) return 0;
535
536 AliRawEvent* subEvent = NULL;
537 Int_t subEventIndex = 0;
94d918a7 538 AliRawEquipment* equipment = NULL;
539 Int_t equipmentIndex = 0;
b4857df7 540 UChar_t* position = 0;
541 UChar_t* end = 0;
be50fca2 542 Int_t result = 0;
b4857df7 543
544 while (kTRUE) {
94d918a7 545 // get the first or the next sub event if at the end of an equipment
546 if (!subEvent || (equipmentIndex >= subEvent->GetNEquipments())) {
b4857df7 547
548 // check for end of event data
be50fca2 549 if (subEventIndex >= fEvent->GetNSubEvents()) return result;
b4857df7 550 subEvent = fEvent->GetSubEvent(subEventIndex++);
551
552 // check the magic word of the sub event
be50fca2 553 if (!fSubEvent->GetHeader()->IsValid()) {
554 result |= kErrMagic;
555 return result;
556 }
b4857df7 557
94d918a7 558 equipmentIndex = 0;
b4857df7 559 }
560
94d918a7 561 // get the next equipment and raw data
562 equipment = subEvent->GetEquipment(equipmentIndex++);
563 if (!equipment) continue;
564 AliRawData* rawData = equipment->GetRawData();
565 if (!rawData) continue;
566 position = (UChar_t*) rawData->GetBuffer();
567 end = ((UChar_t*) rawData->GetBuffer()) + rawData->GetSize();
568
b4857df7 569 // continue with the next sub event if no data left in the payload
570 if (position >= end) continue;
571
18882b3b 572 if (fRequireHeader) {
39f9963f 573 // check that there are enough bytes left for the data header
18882b3b 574 if (position + sizeof(AliRawDataHeader) > end) {
575 result |= kErrNoDataHeader;
576 continue;
577 }
b4857df7 578
18882b3b 579 // check consistency of data size in the header and in the equipment
580 AliRawDataHeader* header = (AliRawDataHeader*) position;
299738b9 581 if ((position + header->fSize) != end) {
806e573c 582 if (header->fSize != 0xFFFFFFFF)
583 Warning("ReadHeader",
584 "Equipment %d : raw data size found in the header is wrong (%d != %d)! Using the equipment size instead !",
585 equipment->GetEquipmentHeader()->GetId(),header->fSize, end - position);
299738b9 586 header->fSize = end - position;
587 result |= kErrSize;
39f9963f 588 }
be50fca2 589 }
299738b9 590 position = end;
b4857df7 591 };
fd0de2e2 592
593 return result;
b4857df7 594}