X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=RAW%2FAliRawReaderRoot.cxx;h=9b840f0e72e43fd5f2dd734cd579ab496b5623eb;hb=a6088e29c9095a7760df72b472c793cab47823f1;hp=ed16d4b8191fbfa395e50a5c812dad0480c90515;hpb=e94ad92c90b8d94fc386e85f7ba4d5bc6abd752d;p=u%2Fmrichter%2FAliRoot.git diff --git a/RAW/AliRawReaderRoot.cxx b/RAW/AliRawReaderRoot.cxx index ed16d4b8191..9b840f0e72e 100644 --- a/RAW/AliRawReaderRoot.cxx +++ b/RAW/AliRawReaderRoot.cxx @@ -21,7 +21,7 @@ /// /// The root file is expected to contain a tree of name "RAW" with /// a branch of name "rawevent" which contains objects of type -/// AliRawEvent. +/// AliRawVEvent. /// /// The file name and the event number are arguments of the constructor /// of AliRawReaderRoot. @@ -31,21 +31,39 @@ #include #include #include "AliRawReaderRoot.h" -#include "AliRawEvent.h" -#include "AliRawEventHeader.h" -#include "AliRawEquipment.h" +#include "AliRawVEvent.h" +#include "AliRawEventHeaderBase.h" +#include "AliRawVEquipment.h" #include "AliRawEquipmentHeader.h" #include "AliRawData.h" ClassImp(AliRawReaderRoot) +AliRawReaderRoot::AliRawReaderRoot() : + fFile(NULL), + fBranch(NULL), + fEventIndex(-1), + fEvent(NULL), + fEventHeader(NULL), + fSubEventIndex(0), + fSubEvent(NULL), + fEquipmentIndex(0), + fEquipment(NULL), + fRawData(NULL), + fPosition(NULL), + fEnd(NULL) +{ +// default constructor + +} AliRawReaderRoot::AliRawReaderRoot(const char* fileName, Int_t eventNumber) : fFile(NULL), fBranch(NULL), fEventIndex(eventNumber), fEvent(NULL), + fEventHeader(NULL), fSubEventIndex(0), fSubEvent(NULL), fEquipmentIndex(0), @@ -62,34 +80,39 @@ AliRawReaderRoot::AliRawReaderRoot(const char* fileName, Int_t eventNumber) : dir->cd(); if (!fFile || !fFile->IsOpen()) { Error("AliRawReaderRoot", "could not open file %s", fileName); + fIsValid = kFALSE; return; } TTree* tree = (TTree*) fFile->Get("RAW"); if (!tree) { Error("AliRawReaderRoot", "no raw data tree found"); + fIsValid = kFALSE; return; } fBranch = tree->GetBranch("rawevent"); if (!fBranch) { Error("AliRawReaderRoot", "no raw data branch found"); + fIsValid = kFALSE; return; } - fEvent = new AliRawEvent; fBranch->SetAddress(&fEvent); if (fEventIndex >= 0) { if (fBranch->GetEntry(fEventIndex) <= 0) { Error("AliRawReaderRoot", "no event with number %d found", fEventIndex); + fIsValid = kFALSE; return; } + fEventHeader = fEvent->GetHeader(); } } -AliRawReaderRoot::AliRawReaderRoot(AliRawEvent* event) : +AliRawReaderRoot::AliRawReaderRoot(AliRawVEvent* event) : fFile(NULL), fBranch(NULL), fEventIndex(-1), fEvent(event), + fEventHeader(event->GetHeader()), fSubEventIndex(0), fSubEvent(NULL), fEquipmentIndex(0), @@ -99,7 +122,7 @@ AliRawReaderRoot::AliRawReaderRoot(AliRawEvent* event) : fEnd(NULL) { // create an object to read digits from the given raw event - + if (!fEvent) fIsValid = kFALSE; } AliRawReaderRoot::AliRawReaderRoot(const AliRawReaderRoot& rawReader) : @@ -108,6 +131,7 @@ AliRawReaderRoot::AliRawReaderRoot(const AliRawReaderRoot& rawReader) : fBranch(NULL), fEventIndex(rawReader.fEventIndex), fEvent(NULL), + fEventHeader(NULL), fSubEventIndex(rawReader.fSubEventIndex), fSubEvent(NULL), fEquipmentIndex(rawReader.fEquipmentIndex), @@ -125,30 +149,35 @@ AliRawReaderRoot::AliRawReaderRoot(const AliRawReaderRoot& rawReader) : if (!fFile || !fFile->IsOpen()) { Error("AliRawReaderRoot", "could not open file %s", rawReader.fFile->GetName()); + fIsValid = kFALSE; return; } TTree* tree = (TTree*) fFile->Get("RAW"); if (!tree) { Error("AliRawReaderRoot", "no raw data tree found"); + fIsValid = kFALSE; return; } fBranch = tree->GetBranch("rawevent"); if (!fBranch) { Error("AliRawReaderRoot", "no raw data branch found"); + fIsValid = kFALSE; return; } - fEvent = new AliRawEvent; fBranch->SetAddress(&fEvent); if (fEventIndex >= 0) { if (fBranch->GetEntry(fEventIndex) <= 0) { Error("AliRawReaderRoot", "no event with number %d found", fEventIndex); + fIsValid = kFALSE; return; } + fEventHeader = fEvent->GetHeader(); } } else { fEvent = rawReader.fEvent; + fEventHeader = rawReader.fEventHeader; } if (fSubEventIndex > 0) { @@ -186,53 +215,59 @@ AliRawReaderRoot::~AliRawReaderRoot() } } +const AliRawEventHeaderBase* AliRawReaderRoot::GetEventHeader() const +{ + // Get the even header + // Return NULL in case of failure + return fEventHeader; +} UInt_t AliRawReaderRoot::GetType() const { // get the type from the event header - if (!fEvent) return 0; - return fEvent->GetHeader()->GetType(); + if (!fEventHeader) return 0; + return fEventHeader->Get("Type"); } UInt_t AliRawReaderRoot::GetRunNumber() const { // get the run number from the event header - if (!fEvent) return 0; - return fEvent->GetHeader()->GetRunNumber(); + if (!fEventHeader) return 0; + return fEventHeader->Get("RunNb"); } const UInt_t* AliRawReaderRoot::GetEventId() const { // get the event id from the event header - if (!fEvent) return NULL; - return fEvent->GetHeader()->GetId(); + if (!fEventHeader) return NULL; + return fEventHeader->GetP("Id"); } const UInt_t* AliRawReaderRoot::GetTriggerPattern() const { // get the trigger pattern from the event header - if (!fEvent) return NULL; - return fEvent->GetHeader()->GetTriggerPattern(); + if (!fEventHeader) return NULL; + return fEventHeader->GetP("TriggerPattern"); } const UInt_t* AliRawReaderRoot::GetDetectorPattern() const { // get the detector pattern from the event header - if (!fEvent) return NULL; - return fEvent->GetHeader()->GetDetectorPattern(); + if (!fEventHeader) return NULL; + return fEventHeader->GetP("DetectorPattern"); } const UInt_t* AliRawReaderRoot::GetAttributes() const { // get the type attributes from the event header - if (!fEvent) return NULL; - return fEvent->GetHeader()->GetTypeAttribute(); + if (!fEventHeader) return NULL; + return fEventHeader->GetP("TypeAttribute"); } const UInt_t* AliRawReaderRoot::GetSubEventAttributes() const @@ -240,7 +275,7 @@ const UInt_t* AliRawReaderRoot::GetSubEventAttributes() const // get the type attributes from the sub event header if (!fSubEvent) return NULL; - return fSubEvent->GetHeader()->GetTypeAttribute(); + return fSubEvent->GetHeader()->GetP("TypeAttribute"); } UInt_t AliRawReaderRoot::GetLDCId() const @@ -248,17 +283,22 @@ UInt_t AliRawReaderRoot::GetLDCId() const // get the LDC Id from the event header if (!fEvent || !fSubEvent) return 0; - return fSubEvent->GetHeader()->GetLDCId(); + return fSubEvent->GetHeader()->Get("LdcId"); } UInt_t AliRawReaderRoot::GetGDCId() const { // get the GDC Id from the event header - if (!fEvent) return 0; - return fEvent->GetHeader()->GetGDCId(); + if (!fEventHeader) return 0; + return fEventHeader->Get("GdcId"); } +UInt_t AliRawReaderRoot::GetTimestamp() const +{ + if (!fEventHeader) return 0; + return fEventHeader->Get("Timestamp"); +} Int_t AliRawReaderRoot::GetEquipmentSize() const { @@ -300,6 +340,30 @@ Int_t AliRawReaderRoot::GetEquipmentElementSize() const return fEquipment->GetEquipmentHeader()->GetBasicSizeType(); } +Int_t AliRawReaderRoot::GetEquipmentHeaderSize() const +{ +// get the size of the equipment header (28 bytes by default) + + if (!fEvent || !fEquipment || !fEquipment->GetEquipmentHeader()) return 0; + return fEquipment->GetEquipmentHeader()->HeaderSize(); +} + +// _________________________________________________________________________ +void AliRawReaderRoot::SwapData(const void* inbuf, const void* outbuf, UInt_t size) { + // The method swaps the contents of the + // raw-data event header + UInt_t intCount = (size+3)/sizeof(UInt_t); + + UInt_t* buf = (UInt_t*) inbuf; // temporary integers buffer + for (UInt_t i=0; i= fSubEvent->GetNEquipments()) { + fEquipment = NULL; + continue; + } fEquipment = fSubEvent->GetEquipment(fEquipmentIndex++); if (!fEquipment) continue; + if (!IsSelected()) { + fPosition = fEnd; + continue; + } fRawData = fEquipment->GetRawData(); if (!fRawData) { fPosition = fEnd; @@ -352,37 +424,52 @@ Bool_t AliRawReaderRoot::ReadHeader() // continue with the next equipment if no data left in the payload if (fPosition >= fEnd) continue; - // check that there are enough bytes left for the data header - if (fPosition + sizeof(AliRawDataHeader) > fEnd) { - Error("ReadHeader", "could not read data header!"); - Warning("ReadHeader", "skipping %d bytes", fEnd - fPosition); - fEquipment->GetEquipmentHeader()->Dump(); - fCount = 0; - fPosition = fEnd; - fErrorCode = kErrNoDataHeader; - continue; + if (fRequireHeader) { + // check that there are enough bytes left for the data header + if (fPosition + sizeof(AliRawDataHeader) > fEnd) { + Error("ReadHeader", "could not read data header!"); + Warning("ReadHeader", "skipping %d bytes", fEnd - fPosition); + fEquipment->GetEquipmentHeader()->Dump(); + fCount = 0; + fPosition = fEnd; + fErrorCode = kErrNoDataHeader; + continue; + } + + // "read" the data header + fHeader = (AliRawDataHeader*) fPosition; +#ifndef R__BYTESWAP + SwapData((void*) fHeader, (void*) fHeaderSwapped, sizeof(AliRawDataHeader)); + fHeader=fHeaderSwapped; +#endif + if ((fPosition + fHeader->fSize) != fEnd) { + if (fHeader->fSize != 0xFFFFFFFF) + Warning("ReadHeader", + "Equipment %d : raw data size found in the header is wrong (%d != %d)! Using the equipment size instead !", + fEquipment->GetEquipmentHeader()->GetId(),fHeader->fSize, fEnd - fPosition); + fHeader->fSize = fEnd - fPosition; + } + fPosition += sizeof(AliRawDataHeader); } - // "read" the data header - fHeader = (AliRawDataHeader*) fPosition; - fPosition += sizeof(AliRawDataHeader); - if (fHeader->fSize != 0xFFFFFFFF) { + if (fHeader && (fHeader->fSize != 0xFFFFFFFF)) { fCount = fHeader->fSize - sizeof(AliRawDataHeader); + + // check consistency of data size in the header and in the sub event + if (fPosition + fCount > fEnd) { + Error("ReadHeader", "size in data header exceeds event size!"); + Warning("ReadHeader", "skipping %d bytes", fEnd - fPosition); + fEquipment->GetEquipmentHeader()->Dump(); + fCount = 0; + fPosition = fEnd; + fErrorCode = kErrSize; + continue; + } + } else { fCount = fEnd - fPosition; } - // check consistency of data size in the header and in the sub event - if (fPosition + fCount > fEnd) { - Error("ReadHeader", "size in data header exceeds event size!"); - Warning("ReadHeader", "skipping %d bytes", fEnd - fPosition); - fEquipment->GetEquipmentHeader()->Dump(); - fCount = 0; - fPosition = fEnd; - fErrorCode = kErrSize; - continue; - } - } while (!IsSelected()); return kTRUE; @@ -415,6 +502,7 @@ Bool_t AliRawReaderRoot::ReadNext(UChar_t* data, Int_t size) return kFALSE; } memcpy(data, fPosition, size); + fPosition += size; fCount -= size; return kTRUE; @@ -442,17 +530,19 @@ Bool_t AliRawReaderRoot::NextEvent() { // go to the next event in the root file - if (!fFile) return kFALSE; + if (!fBranch) return kFALSE; do { - if (fBranch->GetEntry(fEventIndex+1) <= 0) { - delete fEvent; - fEvent = new AliRawEvent; - fBranch->SetAddress(&fEvent); + delete fEvent; + fEvent = NULL; + fEventHeader = NULL; + fBranch->SetAddress(&fEvent); + if (fBranch->GetEntry(fEventIndex+1) <= 0) return kFALSE; - } + fEventHeader = fEvent->GetHeader(); fEventIndex++; } while (!IsEventSelected()); + fEventNumber++; return Reset(); } @@ -460,15 +550,46 @@ Bool_t AliRawReaderRoot::RewindEvents() { // go back to the beginning of the root file - if (!fFile) return kFALSE; + if (!fBranch) return kFALSE; fEventIndex = -1; delete fEvent; - fEvent = new AliRawEvent; + fEvent = NULL; + fEventHeader = NULL; + fBranch->SetAddress(&fEvent); + fEventNumber = -1; + return Reset(); +} + +Bool_t AliRawReaderRoot::GotoEvent(Int_t event) +{ + // go to a particular event + // Uses the absolute event index inside the + // raw-data file + + if (!fBranch) return kFALSE; + + delete fEvent; + fEvent = NULL; + fEventHeader = NULL; fBranch->SetAddress(&fEvent); + if (fBranch->GetEntry(event) <= 0) + return kFALSE; + fEventHeader = fEvent->GetHeader(); + fEventIndex = event; + fEventNumber++; return Reset(); } +Int_t AliRawReaderRoot::GetNumberOfEvents() const +{ + // Get the total number of events in + // the raw-data tree + + if (!fBranch) return -1; + + return fBranch->GetEntries(); +} Int_t AliRawReaderRoot::CheckData() const { @@ -476,9 +597,9 @@ Int_t AliRawReaderRoot::CheckData() const if (!fEvent) return 0; - AliRawEvent* subEvent = NULL; + AliRawVEvent* subEvent = NULL; Int_t subEventIndex = 0; - AliRawEquipment* equipment = NULL; + AliRawVEquipment* equipment = NULL; Int_t equipmentIndex = 0; UChar_t* position = 0; UChar_t* end = 0; @@ -502,6 +623,10 @@ Int_t AliRawReaderRoot::CheckData() const } // get the next equipment and raw data + if (equipmentIndex >= subEvent->GetNEquipments()) { + equipment = NULL; + continue; + } equipment = subEvent->GetEquipment(equipmentIndex++); if (!equipment) continue; AliRawData* rawData = equipment->GetRawData(); @@ -512,20 +637,55 @@ Int_t AliRawReaderRoot::CheckData() const // continue with the next sub event if no data left in the payload if (position >= end) continue; + if (fRequireHeader) { // check that there are enough bytes left for the data header - if (position + sizeof(AliRawDataHeader) > end) { - result |= kErrNoDataHeader; - continue; - } + if (position + sizeof(AliRawDataHeader) > end) { + result |= kErrNoDataHeader; + continue; + } - // check consistency of data size in the header and in the equipment - AliRawDataHeader* header = (AliRawDataHeader*) position; - if (header->fSize != 0xFFFFFFFF) { - if (position + header->fSize > end) { + // check consistency of data size in the header and in the equipment + AliRawDataHeader* header = (AliRawDataHeader*) position; + if ((position + header->fSize) != end) { + if (header->fSize != 0xFFFFFFFF) + Warning("ReadHeader", + "Equipment %d : raw data size found in the header is wrong (%d != %d)! Using the equipment size instead !", + equipment->GetEquipmentHeader()->GetId(),header->fSize, end - position); + header->fSize = end - position; result |= kErrSize; } } + position = end; }; return result; } + +AliRawReader* AliRawReaderRoot::CloneSingleEvent() const +{ + // Clones the current event and + // creates raw-reader for the cloned event + // Can be used in order to make asynchronious + // access to the current raw data within + // several threads (online event display/reco) + + if (fEvent) { + // Root formatted raw data + AliRawVEvent *gdcRootEvent = (AliRawVEvent*)fEvent->Clone(); + for (Int_t ldcCounter=0; ldcCounter < gdcRootEvent->GetNSubEvents(); ldcCounter++) { + AliRawVEvent *ldcRootEvent = gdcRootEvent->GetSubEvent(ldcCounter); + AliRawVEvent *subEvent = fEvent->GetSubEvent(ldcCounter); + for (Int_t eqCounter=0; eqCounter < ldcRootEvent->GetNEquipments(); eqCounter++) { + AliRawVEquipment *equipment=ldcRootEvent->GetEquipment(eqCounter); + AliRawVEquipment *eq = subEvent->GetEquipment(eqCounter); + equipment->CloneRawData(eq->GetRawData()); + } + } + // Reset original event and newly + // produced one + gdcRootEvent->GetSubEvent(-1); + fEvent->GetSubEvent(-1); + return new AliRawReaderRoot(gdcRootEvent); + } + return NULL; +}