X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=RAW%2FAliRawReaderRoot.cxx;h=97f92858c553ee018824de825d06a19d7612fb74;hb=79e78b75e5684410f302e75a2b2bf84168a1a73a;hp=84c10ce669b37ac196267e8c2024489bdf9d8c63;hpb=18882b3b6521280c033377aca6bd7cc137f33d28;p=u%2Fmrichter%2FAliRoot.git diff --git a/RAW/AliRawReaderRoot.cxx b/RAW/AliRawReaderRoot.cxx index 84c10ce669b..97f92858c55 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. @@ -30,29 +30,52 @@ #include #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) +Bool_t AliRawReaderRoot::fgUseOrder = kFALSE; +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), + fIndex(0x0) +{ +// 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), fEquipment(NULL), fRawData(NULL), fPosition(NULL), - fEnd(NULL) + fEnd(NULL), + fIndex(0x0) { // create an object to read digits from the given input file for the // event with the given number @@ -62,44 +85,50 @@ 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), fEquipment(NULL), fRawData(NULL), fPosition(NULL), - fEnd(NULL) + fEnd(NULL), + fIndex(0x0) { // create an object to read digits from the given raw event - + if (!fEvent) fIsValid = kFALSE; } AliRawReaderRoot::AliRawReaderRoot(const AliRawReaderRoot& rawReader) : @@ -108,13 +137,15 @@ AliRawReaderRoot::AliRawReaderRoot(const AliRawReaderRoot& rawReader) : fBranch(NULL), fEventIndex(rawReader.fEventIndex), fEvent(NULL), + fEventHeader(NULL), fSubEventIndex(rawReader.fSubEventIndex), fSubEvent(NULL), fEquipmentIndex(rawReader.fEquipmentIndex), fEquipment(NULL), fRawData(NULL), fPosition(NULL), - fEnd(NULL) + fEnd(NULL), + fIndex(0x0) { // copy constructor @@ -125,40 +156,54 @@ 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) { fSubEvent = fEvent->GetSubEvent(fSubEventIndex-1); fEquipment = fSubEvent->GetEquipment(fEquipmentIndex); fRawData = fEquipment->GetRawData(); - fCount = 0; + fCount = 0; fHeader = (AliRawDataHeader*) ((UChar_t*) fRawData->GetBuffer() + ((UChar_t*) rawReader.fHeader - (UChar_t*) rawReader.fRawData->GetBuffer())); + // Now check the version of the header + UChar_t version = 2; + if (fHeader) version = fHeader->GetVersion(); + if (version==3) { + fHeader = NULL; + fHeaderV3 = (AliRawDataHeaderV3*) ((UChar_t*) fRawData->GetBuffer() + + ((UChar_t*) rawReader.fHeaderV3 - + (UChar_t*) rawReader.fRawData->GetBuffer())); + } fPosition = (UChar_t*) fRawData->GetBuffer() + (rawReader.fPosition - (UChar_t*) rawReader.fRawData->GetBuffer()); fEnd = ((UChar_t*) fRawData->GetBuffer()) + fRawData->GetSize(); @@ -186,53 +231,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 +291,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 +299,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 +356,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; @@ -356,7 +444,7 @@ Bool_t AliRawReaderRoot::ReadHeader() // 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); + Warning("ReadHeader", "skipping %ld bytes", fEnd - fPosition); fEquipment->GetEquipmentHeader()->Dump(); fCount = 0; fPosition = fEnd; @@ -366,26 +454,72 @@ Bool_t AliRawReaderRoot::ReadHeader() // "read" the data header fHeader = (AliRawDataHeader*) fPosition; - fPosition += sizeof(AliRawDataHeader); + // Now check the version of the header + UChar_t version = 2; + if (fHeader) version=fHeader->GetVersion(); + if (version==2) { + #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 != %ld)! Using the equipment size instead !", + fEquipment->GetEquipmentHeader()->GetId(),fHeader->fSize, fEnd - fPosition); + fHeader->fSize = fEnd - fPosition; + } + fPosition += sizeof(AliRawDataHeader); + fHeaderV3 = 0; + } else if (version==3) { + fHeaderV3 = (AliRawDataHeaderV3*) fPosition; +#ifndef R__BYTESWAP + SwapData((void*) fHeaderV3, (void*) fHeaderSwapped, sizeof(AliRawDataHeaderV3)); + fHeaderV3=fHeaderSwappedV3; +#endif + if ((fPosition + fHeaderV3->fSize) != fEnd) { + if (fHeaderV3->fSize != 0xFFFFFFFF) + Warning("ReadHeader", + "Equipment %d : raw data size found in the header is wrong (%d != %ld)! Using the equipment size instead !", + fEquipment->GetEquipmentHeader()->GetId(),fHeader->fSize, fEnd - fPosition); + fHeaderV3->fSize = fEnd - fPosition; + } + fPosition += sizeof(AliRawDataHeaderV3); + fHeader = 0; + } } - 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 %ld bytes", fEnd - fPosition); + fEquipment->GetEquipmentHeader()->Dump(); + fCount = 0; + fPosition = fEnd; + fErrorCode = kErrSize; + continue; + } + } else if (fHeaderV3 && (fHeaderV3->fSize != 0xFFFFFFFF)) { + fCount = fHeaderV3->fSize - sizeof(AliRawDataHeaderV3); + + // 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 %ld 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; @@ -418,6 +552,7 @@ Bool_t AliRawReaderRoot::ReadNext(UChar_t* data, Int_t size) return kFALSE; } memcpy(data, fPosition, size); + fPosition += size; fCount -= size; return kTRUE; @@ -434,6 +569,7 @@ Bool_t AliRawReaderRoot::Reset() fEquipment = NULL; fRawData = NULL; fHeader = NULL; + fHeaderV3 = NULL; fCount = 0; fPosition = fEnd = NULL; @@ -445,17 +581,27 @@ Bool_t AliRawReaderRoot::NextEvent() { // go to the next event in the root file - if (!fFile) return kFALSE; + if (!fBranch) return kFALSE; + + // check if it uses order or not + if (fgUseOrder && !fIndex) MakeIndex(); do { - if (fBranch->GetEntry(fEventIndex+1) <= 0) { - delete fEvent; - fEvent = new AliRawEvent; - fBranch->SetAddress(&fEvent); + delete fEvent; + fEvent = NULL; + fEventHeader = NULL; + fBranch->SetAddress(&fEvent); + Int_t entryToGet = fEventIndex + 1; + if (fgUseOrder + && fIndex + && entryToGetGetEntries() + && entryToGet>-1 ) entryToGet = fIndex[entryToGet]; + if (fBranch->GetEntry(entryToGet) <= 0) return kFALSE; - } + fEventHeader = fEvent->GetHeader(); fEventIndex++; } while (!IsEventSelected()); + fEventNumber++; return Reset(); } @@ -463,15 +609,54 @@ 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; + + // check if it uses order or not + if (fgUseOrder && !fIndex) MakeIndex(); + + delete fEvent; + fEvent = NULL; + fEventHeader = NULL; fBranch->SetAddress(&fEvent); + Int_t entryToGet = event; + if (fgUseOrder + && fIndex + && entryToGetGetEntries() + && entryToGet>-1 ) entryToGet = fIndex[entryToGet]; + if (fBranch->GetEntry(entryToGet) <= 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 { @@ -479,9 +664,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; @@ -505,6 +690,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(); @@ -524,13 +713,58 @@ Int_t AliRawReaderRoot::CheckData() const // 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) { - result |= kErrSize; - } + if ((position + header->fSize) != end) { + if (header->fSize != 0xFFFFFFFF) + Warning("ReadHeader", + "Equipment %d : raw data size found in the header is wrong (%d != %ld)! 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; +} + +void AliRawReaderRoot::MakeIndex() { + // Make index + if (fBranch) { + TTree * rawTree = fBranch->GetTree(); + if (rawTree) { + rawTree->BuildIndex("-fEvtHdrs[0].fSize"); // Minus sign to get largest first + TTreeIndex * treeInd = (TTreeIndex*)rawTree->GetTreeIndex(); + if (treeInd) fIndex = treeInd->GetIndex(); + } + } +}