X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=RAW%2FAliRawReaderRoot.cxx;h=9b840f0e72e43fd5f2dd734cd579ab496b5623eb;hb=0e51d0974ddc6919db8c3e26563975199cf2acbe;hp=8d2f04227961546769d0890b1af6325513b82782;hpb=3d65cc80e32dbb125d4d01e19d6e104b39eff914;p=u%2Fmrichter%2FAliRoot.git diff --git a/RAW/AliRawReaderRoot.cxx b/RAW/AliRawReaderRoot.cxx index 8d2f0422796..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 "AliRawVEvent.h" #include "AliRawEventHeaderBase.h" -#include "AliRawEquipment.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) { @@ -190,56 +219,55 @@ const AliRawEventHeaderBase* AliRawReaderRoot::GetEventHeader() const { // Get the even header // Return NULL in case of failure - if (!fEvent) return NULL; - return fEvent->GetHeader(); + return fEventHeader; } UInt_t AliRawReaderRoot::GetType() const { // get the type from the event header - if (!fEvent) return 0; - return fEvent->GetHeader()->Get("Type"); + 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()->Get("RunNb"); + 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()->GetP("Id"); + 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()->GetP("TriggerPattern"); + 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()->GetP("DetectorPattern"); + 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()->GetP("TypeAttribute"); + if (!fEventHeader) return NULL; + return fEventHeader->GetP("TypeAttribute"); } const UInt_t* AliRawReaderRoot::GetSubEventAttributes() const @@ -262,10 +290,15 @@ UInt_t AliRawReaderRoot::GetGDCId() const { // get the GDC Id from the event header - if (!fEvent) return 0; - return fEvent->GetHeader()->Get("GdcId"); + 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 { @@ -315,6 +348,22 @@ Int_t AliRawReaderRoot::GetEquipmentHeaderSize() const 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()) { @@ -385,10 +438,15 @@ Bool_t AliRawReaderRoot::ReadHeader() // "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) { - 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); + 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); @@ -444,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; @@ -471,14 +530,16 @@ Bool_t AliRawReaderRoot::NextEvent() { // go to the next event in the root file - if (!fFile) return kFALSE; + if (!fBranch) return kFALSE; do { delete fEvent; - fEvent = new AliRawEvent; + fEvent = NULL; + fEventHeader = NULL; fBranch->SetAddress(&fEvent); if (fBranch->GetEntry(fEventIndex+1) <= 0) return kFALSE; + fEventHeader = fEvent->GetHeader(); fEventIndex++; } while (!IsEventSelected()); fEventNumber++; @@ -489,16 +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 { @@ -506,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; @@ -532,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(); @@ -552,9 +647,10 @@ Int_t AliRawReaderRoot::CheckData() const // check consistency of data size in the header and in the equipment AliRawDataHeader* header = (AliRawDataHeader*) position; if ((position + header->fSize) != end) { - 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); + 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; } @@ -564,3 +660,32 @@ Int_t AliRawReaderRoot::CheckData() const 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; +}