functionality of raw readers extended to read more than one event
authortkuhr <tkuhr@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 2 Jul 2004 13:25:44 +0000 (13:25 +0000)
committertkuhr <tkuhr@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 2 Jul 2004 13:25:44 +0000 (13:25 +0000)
RAW/AliRawReader.cxx
RAW/AliRawReader.h
RAW/AliRawReaderDate.cxx
RAW/AliRawReaderDate.h
RAW/AliRawReaderFile.cxx
RAW/AliRawReaderFile.h
RAW/AliRawReaderRoot.cxx
RAW/AliRawReaderRoot.h

index 2fcdc13..ced8011 100644 (file)
@@ -49,6 +49,7 @@ AliRawReader::AliRawReader() :
   fSelectMinEquipmentId(-1),
   fSelectMaxEquipmentId(-1),
   fSkipInvalid(kFALSE),
+  fSelectEventType(-1),
   fErrorCode(0)
 {
 // default constructor: initialize data members
@@ -63,6 +64,7 @@ AliRawReader::AliRawReader(const AliRawReader& rawReader) :
   fSelectMinEquipmentId(rawReader.fSelectMinEquipmentId),
   fSelectMaxEquipmentId(rawReader.fSelectMaxEquipmentId),
   fSkipInvalid(rawReader.fSkipInvalid),
+  fSelectEventType(rawReader.fSelectEventType),
   fErrorCode(0)
 {
 // copy constructor
@@ -80,6 +82,7 @@ AliRawReader& AliRawReader::operator = (const AliRawReader& rawReader)
   fSelectMinEquipmentId = rawReader.fSelectMinEquipmentId;
   fSelectMaxEquipmentId = rawReader.fSelectMaxEquipmentId;
   fSkipInvalid = rawReader.fSkipInvalid;
+  fSelectEventType = rawReader.fSelectEventType;
 
   fErrorCode = rawReader.fErrorCode;
 
@@ -112,6 +115,14 @@ void AliRawReader::SelectEquipment(Int_t equipmentType,
   fSelectMaxEquipmentId = maxEquipmentId;
 }
 
+void AliRawReader::SelectEvents(Int_t type)
+{
+// read only events with the given type.
+// no selection is applied if a value < 0 is used.
+
+  fSelectEventType = type;
+}
+
 Bool_t AliRawReader::IsSelected() const
 {
 // apply the selection (if any)
@@ -131,6 +142,17 @@ Bool_t AliRawReader::IsSelected() const
   return kTRUE;
 }
 
+Bool_t AliRawReader::IsEventSelected() const
+{
+// apply the event selection (if any)
+
+  if (fSelectEventType >= 0) {
+    if (GetType() != (UInt_t) fSelectEventType) return kFALSE;
+  }
+
+  return kTRUE;
+}
+
 
 Bool_t AliRawReader::ReadNextInt(UInt_t& data)
 {
index 8aedf04..a7093e7 100644 (file)
@@ -29,6 +29,7 @@ class AliRawReader: public TObject {
                                     Int_t maxEquipmentId = -1);
     void             SkipInvalid(Bool_t skip = kTRUE)
       {fSkipInvalid = skip;};
+    void             SelectEvents(Int_t type);
 
     virtual UInt_t   GetType() const = 0;
     virtual UInt_t   GetRunNumber() const = 0;
@@ -71,6 +72,9 @@ class AliRawReader: public TObject {
 
     virtual Bool_t   Reset() = 0;
 
+    virtual Bool_t   NextEvent() = 0;
+    virtual Bool_t   RewindEvents() = 0;
+
     enum {kErrMagic=1, kErrNoDataHeader=2, 
          kErrSize=4, kErrOutOfBounds=8};
     virtual Int_t    CheckData() const;
@@ -80,6 +84,7 @@ class AliRawReader: public TObject {
 
   protected :
     Bool_t           IsSelected() const;
+    Bool_t           IsEventSelected() const;
 
     virtual Bool_t   ReadNext(UChar_t* data, Int_t size) = 0;
 
@@ -90,6 +95,7 @@ class AliRawReader: public TObject {
     Int_t            fSelectMinEquipmentId; // minimal index of selected equipment (<0 = no selection)
     Int_t            fSelectMaxEquipmentId; // maximal index of selected equipment (<0 = no selection)
     Bool_t           fSkipInvalid;       // skip invalid data
+    Int_t            fSelectEventType;   // type of selected events (<0 = no selection)
 
     Int_t            fErrorCode;         // code of last error
 
index 74b86ac..4c0f5f9 100644 (file)
@@ -40,10 +40,10 @@ AliRawReaderDate::AliRawReaderDate(
 #endif
                                   ) :
   fRequireHeader(kTRUE),
+  fFile(NULL),
   fEvent(NULL),
   fSubEvent(NULL),
   fEquipment(NULL),
-  fIsOwner(kFALSE),
   fPosition(NULL),
   fEnd(NULL)
 {
@@ -65,36 +65,36 @@ AliRawReaderDate::AliRawReaderDate(
 #endif
                                   ) :
   fRequireHeader(kTRUE),
+  fFile(NULL),
   fEvent(NULL),
   fSubEvent(NULL),
   fEquipment(NULL),
-  fIsOwner(kFALSE),
   fPosition(NULL),
   fEnd(NULL)
 {
 // create an object to read digits from the given date event
 
 #ifdef ALI_DATE
-  FILE* file = fopen(fileName, "rb");
-  if (!file) {
+  fFile = fopen(fileName, "rb");
+  if (!fFile) {
     Error("AliRawReaderDate", "could not open file %s", fileName);
     return;
   }
+  if (eventNumber < 0) return;
+
   eventHeaderStruct header;
   UInt_t headerSize = sizeof(eventHeaderStruct);
-  while (fread(&header, 1, headerSize, file) == headerSize) {
+  while (fread(&header, 1, headerSize, fFile) == headerSize) {
     if (eventNumber == 0) {
       UChar_t* buffer = new UChar_t[header.eventSize];
-      fseek(file, -headerSize, SEEK_CUR);
-      if (fread(buffer, 1, header.eventSize, file) != header.eventSize) break;
+      fseek(fFile, -headerSize, SEEK_CUR);
+      if (fread(buffer, 1, header.eventSize, fFile) != header.eventSize) break;
       fEvent = (eventHeaderStruct*) buffer;
-      fIsOwner = kTRUE;
       break;
     }
-    fseek(file, header.eventSize-headerSize, SEEK_CUR);
+    fseek(fFile, header.eventSize-headerSize, SEEK_CUR);
     eventNumber--;
   }
-  fclose(file);
 
 #else
   Fatal("AliRawReaderDate", "this class was compiled without DATE");
@@ -104,25 +104,25 @@ AliRawReaderDate::AliRawReaderDate(
 AliRawReaderDate::AliRawReaderDate(const AliRawReaderDate& rawReader) :
   AliRawReader(rawReader),
   fRequireHeader(rawReader.fRequireHeader),
+  fFile(rawReader.fFile),
   fEvent(rawReader.fEvent),
   fSubEvent(rawReader.fSubEvent),
   fEquipment(rawReader.fEquipment),
-  fIsOwner(kFALSE),
   fPosition(rawReader.fPosition),
   fEnd(rawReader.fEnd)
 
 {
 // copy constructor
 
+  Fatal("AliRawReaderDate", "copy constructor not implemented");
 }
 
 AliRawReaderDate& AliRawReaderDate::operator = (const AliRawReaderDate& 
-                                               rawReader)
+                                               /*rawReader*/)
 {
 // assignment operator
 
-  this->~AliRawReaderDate();
-  new(this) AliRawReaderDate(rawReader);
+  Fatal("operator =", "assignment operator not implemented");
   return *this;
 }
 
@@ -131,7 +131,10 @@ AliRawReaderDate::~AliRawReaderDate()
 // destructor
 
 #ifdef ALI_DATE
-  if (fIsOwner) delete[] fEvent;
+  if (fFile) {
+    delete[] fEvent;
+    fclose(fFile);
+  }
 #endif
 }
 
@@ -461,6 +464,48 @@ Bool_t AliRawReaderDate::Reset()
 }
 
 
+Bool_t AliRawReaderDate::NextEvent()
+{
+// go to the next event in the date file
+
+  if (!fFile) return kFALSE;
+
+  eventHeaderStruct header;
+  UInt_t headerSize = sizeof(eventHeaderStruct);
+  if (fEvent) delete[] fEvent;
+  fEvent = &header;
+
+  while (fread(&header, 1, headerSize, fFile) == headerSize) {
+    if (!IsEventSelected()) {
+      fseek(fFile, header.eventSize-headerSize, SEEK_CUR);
+      continue;
+    }
+    UChar_t* buffer = new UChar_t[header.eventSize];
+    fseek(fFile, -headerSize, SEEK_CUR);
+    if (fread(buffer, 1, header.eventSize, fFile) != header.eventSize) {
+      Error("NextEvent", "could not read event from file");
+      delete[] buffer;
+      break;
+    }
+    fEvent = (eventHeaderStruct*) buffer;
+    return kTRUE;
+  };
+
+  fEvent = NULL;
+  return kFALSE;
+}
+
+Bool_t AliRawReaderDate::RewindEvents()
+{
+// go back to the beginning of the date file
+
+  if (!fFile) return kFALSE;
+
+  fseek(fFile, 0, SEEK_SET);
+  return Reset();
+}
+
+
 Int_t AliRawReaderDate::CheckData() const
 {
 // check the consistency of the data
index 09d9226..66495d6 100644 (file)
@@ -20,9 +20,7 @@ struct equipmentHeaderStruct;
 class AliRawReaderDate: public AliRawReader {
   public :
     AliRawReaderDate(void* event);
-    AliRawReaderDate(const char* fileName, Int_t eventNumber);
-    AliRawReaderDate(const AliRawReaderDate& rawReader);
-    AliRawReaderDate& operator = (const AliRawReaderDate& rawReader);
+    AliRawReaderDate(const char* fileName, Int_t eventNumber = -1);
     virtual ~AliRawReaderDate();
 
     void             RequireHeader(Bool_t required = kTRUE)
@@ -48,6 +46,9 @@ class AliRawReaderDate: public AliRawReader {
 
     virtual Bool_t   Reset();
 
+    virtual Bool_t   NextEvent();
+    virtual Bool_t   RewindEvents();
+
     virtual Int_t    CheckData() const;
 
   protected :
@@ -55,14 +56,18 @@ class AliRawReaderDate: public AliRawReader {
 
     Bool_t           fRequireHeader; // if false, data without header is accepted
 
+    FILE*            fFile;         // DATE file
     eventHeaderStruct* fEvent;      // raw data super event
     eventHeaderStruct* fSubEvent;   // raw data sub event
     equipmentHeaderStruct* fEquipment; // raw data equipment header
-    Bool_t           fIsOwner;      // flag for ownership of fEvent
 
     UChar_t*         fPosition;     // current position in the raw data
     UChar_t*         fEnd;          // end position of the current data block
 
+  private:
+    AliRawReaderDate(const AliRawReaderDate& rawReader);
+    AliRawReaderDate& operator = (const AliRawReaderDate& rawReader);
+
     ClassDef(AliRawReaderDate, 0) // class for reading raw digits from a root file
 };
 
index 2fa103e..ebc97d5 100644 (file)
@@ -38,7 +38,8 @@ ClassImp(AliRawReaderFile)
 
 
 AliRawReaderFile::AliRawReaderFile(Int_t eventNumber) :
-  fDirName("raw"),
+  fEventIndex(eventNumber),
+  fDirName("."),
   fDirectory(NULL),
   fStream(NULL),
   fEquipmentId(-1),
@@ -46,17 +47,15 @@ AliRawReaderFile::AliRawReaderFile(Int_t eventNumber) :
   fBufferSize(0)
 {
 // create an object to read digits from the given event
+// in the current directory
 
-  fDirName += eventNumber;
-  fDirectory = gSystem->OpenDirectory(fDirName);
-  if (!fDirectory) {
-    Error("AliRawReaderFile", "could not open directory %s", fDirName.Data());
-  }
+  fDirectory = OpenDirectory();
   OpenNextFile();
   fHeader = new AliRawDataHeader;
 }
 
-AliRawReaderFile::AliRawReaderFile(const char* dirName) :
+AliRawReaderFile::AliRawReaderFile(const char* dirName, Int_t eventNumber) :
+  fEventIndex(eventNumber),
   fDirName(dirName),
   fDirectory(NULL),
   fStream(NULL),
@@ -66,10 +65,7 @@ AliRawReaderFile::AliRawReaderFile(const char* dirName) :
 {
 // create an object to read digits from the given directory
 
-  fDirectory = gSystem->OpenDirectory(fDirName);
-  if (!fDirectory) {
-    Error("AliRawReaderFile", "could not open directory %s", fDirName.Data());
-  }
+  fDirectory = OpenDirectory();
   OpenNextFile();
   fHeader = new AliRawDataHeader;
 }
@@ -105,6 +101,30 @@ AliRawReaderFile::~AliRawReaderFile()
 }
 
 
+TString AliRawReaderFile::GetDirName() const
+{
+// return the current directory name
+
+  TString dirName(fDirName);
+  if (fEventIndex >= 0) {
+    dirName += "/raw";
+    dirName += fEventIndex;
+  }
+  return dirName;
+}
+
+void* AliRawReaderFile::OpenDirectory()
+{
+// open and return the directory
+
+  TString dirName = GetDirName();
+  void* directory = gSystem->OpenDirectory(dirName);
+  if (!directory) {
+    Error("OpenDirectory", "could not open directory %s", dirName.Data());
+  }
+  return directory;
+}
+
 Bool_t AliRawReaderFile::OpenNextFile()
 {
 // open the next file
@@ -126,7 +146,7 @@ Bool_t AliRawReaderFile::OpenNextFile()
   while (entry = gSystem->GetDirEntry(fDirectory)) {
     if (entry.IsNull()) return kFALSE;
     if (!entry.EndsWith(".ddl")) continue;
-    char* fileName = gSystem->ConcatFileName(fDirName, entry);
+    char* fileName = gSystem->ConcatFileName(GetDirName(), entry);
 #ifndef __DECCXX 
     fStream = new fstream(fileName, ios::binary|ios::in);
 #else
@@ -209,13 +229,10 @@ Bool_t AliRawReaderFile::ReadNext(UChar_t* data, Int_t size)
 
 Bool_t AliRawReaderFile::Reset()
 {
-// reset the current stream position to the beginning of the file
+// reset the current stream position to the first DDL file of the curevent
 
-  void* directory = gSystem->OpenDirectory(fDirName);
-  if (!directory) {
-    Error("Reset", "could not open directory %s", fDirName.Data());
-    return kFALSE;
-  }
+  void* directory = OpenDirectory();
+  if (!directory) return kFALSE;
 
   if (fStream) {
 #if defined(__HP_aCC) || defined(__DECCXX)
@@ -235,3 +252,30 @@ Bool_t AliRawReaderFile::Reset()
   return kTRUE;
 }
 
+Bool_t AliRawReaderFile::NextEvent()
+{
+// go to the next event directory
+
+  if (fEventIndex < -1) return kFALSE;
+
+  do {
+    TString dirName = fDirName + "/raw";
+    dirName += (fEventIndex + 1);
+    void* directory = gSystem->OpenDirectory(dirName);
+    if (!directory) return kFALSE;
+    gSystem->FreeDirectory(directory);
+
+    fEventIndex++;
+    Reset();
+  } while (!IsEventSelected());
+
+  return kTRUE;
+}
+
+Bool_t AliRawReaderFile::RewindEvents()
+{
+// reset the event counter
+
+  if (fEventIndex >= 0)  fEventIndex = -1;
+  return Reset();
+}
index 71a366c..ae4d989 100644 (file)
@@ -22,8 +22,8 @@ class fstream;
 
 class AliRawReaderFile: public AliRawReader {
   public :
-    AliRawReaderFile(Int_t eventNumber);
-    AliRawReaderFile(const char* dirName);
+    AliRawReaderFile(Int_t eventNumber = -1);
+    AliRawReaderFile(const char* dirName, Int_t eventNumber = -1);
     AliRawReaderFile(const AliRawReaderFile& rawReader);
     AliRawReaderFile& operator = (const AliRawReaderFile& rawReader);
     virtual ~AliRawReaderFile();
@@ -48,11 +48,17 @@ class AliRawReaderFile: public AliRawReader {
 
     virtual Bool_t   Reset();
 
+    virtual Bool_t   NextEvent();
+    virtual Bool_t   RewindEvents();
+
   protected :
+    TString          GetDirName() const;
+    void*            OpenDirectory();
     Bool_t           OpenNextFile();
 
     virtual Bool_t   ReadNext(UChar_t* data, Int_t size);
 
+    Int_t            fEventIndex;  // index of the event
     TString          fDirName;     // name of the input directory
     void*            fDirectory;   // pointer to the input directory
     fstream*         fStream;      // stream of raw digits
index 93d4da7..c963e33 100644 (file)
 ClassImp(AliRawReaderRoot)
 
 
-AliRawReaderRoot::AliRawReaderRoot(const char* fileName, Int_t eventNumber)
+AliRawReaderRoot::AliRawReaderRoot(const char* fileName, Int_t eventNumber) :
+  fFile(NULL),
+  fBranch(NULL),
+  fEventIndex(eventNumber),
+  fEvent(NULL),
+  fSubEventIndex(0),
+  fSubEvent(NULL),
+  fRawData(NULL),
+  fPosition(NULL),
+  fEnd(NULL)
 {
 // create an object to read digits from the given input file for the
 // event with the given number
 
-  fEvent = NULL;
   TDirectory* dir = gDirectory;
   fFile = TFile::Open(fileName);
   dir->cd();
@@ -58,60 +66,95 @@ AliRawReaderRoot::AliRawReaderRoot(const char* fileName, Int_t eventNumber)
     Error("AliRawReaderRoot", "no raw data tree found");
     return;
   }
-  TBranch* branch = tree->GetBranch("rawevent");
-  if (!branch) {
+  fBranch = tree->GetBranch("rawevent");
+  if (!fBranch) {
     Error("AliRawReaderRoot", "no raw data branch found");
     return;
   }
 
   fEvent = new AliRawEvent;
-  branch->SetAddress(&fEvent);
-  if (branch->GetEntry(eventNumber) <= 0) {
-    Error("AliRawReaderRoot", "no event with number %d found", eventNumber);
-    return;
+  fBranch->SetAddress(&fEvent);
+  if (fEventIndex >= 0) {
+    if (fBranch->GetEntry(fEventIndex) <= 0) {
+      Error("AliRawReaderRoot", "no event with number %d found", fEventIndex);
+      return;
+    }
   }
-  
-  fSubEventIndex = 0;
-  fSubEvent = NULL;
-  fRawData = NULL;
-  fHeader = NULL;
-
-  fCount = 0;
-  fPosition = fEnd = NULL;
 }
 
-AliRawReaderRoot::AliRawReaderRoot(AliRawEvent* event)
+AliRawReaderRoot::AliRawReaderRoot(AliRawEvent* event) :
+  fFile(NULL),
+  fBranch(NULL),
+  fEventIndex(-1),
+  fEvent(event),
+  fSubEventIndex(0),
+  fSubEvent(NULL),
+  fRawData(NULL),
+  fPosition(NULL),
+  fEnd(NULL)
 {
 // create an object to read digits from the given raw event
 
-  fFile = NULL;
-  fEvent = event;
-  
-  fSubEventIndex = 0;
-  fSubEvent = NULL;
-  fRawData = NULL;
-  fHeader = NULL;
-
-  fCount = 0;
-  fPosition = fEnd = NULL;
 }
 
 AliRawReaderRoot::AliRawReaderRoot(const AliRawReaderRoot& rawReader) :
-  AliRawReader(rawReader)
+  AliRawReader(rawReader),
+  fFile(NULL),
+  fBranch(NULL),
+  fEventIndex(rawReader.fEventIndex),
+  fEvent(NULL),
+  fSubEventIndex(rawReader.fSubEventIndex),
+  fSubEvent(NULL),
+  fRawData(NULL),
+  fPosition(NULL),
+  fEnd(NULL)
 {
 // copy constructor
 
-  fFile = NULL;
-  fEvent = rawReader.fEvent;
-  
-  fSubEventIndex = rawReader.fSubEventIndex;
-  fSubEvent = rawReader.fSubEvent;
-  fRawData = rawReader.fRawData;
-  fHeader = rawReader.fHeader;
-
-  fCount = rawReader.fCount;
-  fPosition = rawReader.fPosition;
-  fEnd = rawReader.fEnd;
+  if (rawReader.fFile) {
+    TDirectory* dir = gDirectory;
+    fFile = TFile::Open(rawReader.fFile->GetName());
+    dir->cd();
+    if (!fFile || !fFile->IsOpen()) {
+      Error("AliRawReaderRoot", "could not open file %s", 
+           rawReader.fFile->GetName());
+      return;
+    }
+    TTree* tree = (TTree*) fFile->Get("RAW");
+    if (!tree) {
+      Error("AliRawReaderRoot", "no raw data tree found");
+      return;
+    }
+    fBranch = tree->GetBranch("rawevent");
+    if (!fBranch) {
+      Error("AliRawReaderRoot", "no raw data branch found");
+      return;
+    }
+
+    fEvent = new AliRawEvent;
+    fBranch->SetAddress(&fEvent);
+    if (fEventIndex >= 0) {
+      if (fBranch->GetEntry(fEventIndex) <= 0) {
+       Error("AliRawReaderRoot", "no event with number %d found", 
+             fEventIndex);
+       return;
+      }
+    }
+  } else {
+    fEvent = rawReader.fEvent;
+  }
+
+  if (fSubEventIndex > 0) {
+    fSubEvent = fEvent->GetSubEvent(fSubEventIndex-1);
+    fRawData = fSubEvent->GetRawData();
+      fCount = 0;
+    fHeader = (AliRawDataHeader*) ((UChar_t*) fRawData->GetBuffer() + 
+      ((UChar_t*) rawReader.fHeader - 
+       (UChar_t*) rawReader.fRawData->GetBuffer()));
+    fPosition = (UChar_t*) fRawData->GetBuffer() + 
+      (rawReader.fPosition - (UChar_t*) rawReader.fRawData->GetBuffer());
+    fEnd = ((UChar_t*) fRawData->GetBuffer()) + fRawData->GetSize();
+  }
 }
 
 AliRawReaderRoot& AliRawReaderRoot::operator = (const AliRawReaderRoot& 
@@ -362,6 +405,38 @@ Bool_t AliRawReaderRoot::Reset()
 }
 
 
+Bool_t AliRawReaderRoot::NextEvent()
+{
+// go to the next event in the root file
+
+  if (!fFile) return kFALSE;
+
+  do {
+    if (fBranch->GetEntry(fEventIndex+1) <= 0) {
+      delete fEvent;
+      fEvent = new AliRawEvent;
+      fBranch->SetAddress(&fEvent);
+      return kFALSE;
+    }
+    fEventIndex++;
+  } while (!IsEventSelected());
+  return Reset();
+}
+
+Bool_t AliRawReaderRoot::RewindEvents()
+{
+// go back to the beginning of the root file
+
+  if (!fFile) return kFALSE;
+
+  fEventIndex = -1;
+  delete fEvent;
+  fEvent = new AliRawEvent;
+  fBranch->SetAddress(&fEvent);
+  return Reset();
+}
+
+
 Int_t AliRawReaderRoot::CheckData() const
 {
 // check the consistency of the data
index 35d8b25..e300eb0 100644 (file)
 class AliRawEvent;
 class AliRawData;
 class TFile;
+class TBranch;
 
 
 class AliRawReaderRoot: public AliRawReader {
   public :
-    AliRawReaderRoot(const char* fileName, Int_t eventNumber);
+    AliRawReaderRoot(const char* fileName, Int_t eventNumber = -1);
     AliRawReaderRoot(AliRawEvent* event);
     AliRawReaderRoot(const AliRawReaderRoot& rawReader);
     AliRawReaderRoot& operator = (const AliRawReaderRoot& rawReader);
@@ -46,12 +47,17 @@ class AliRawReaderRoot: public AliRawReader {
 
     virtual Bool_t   Reset();
 
+    virtual Bool_t   NextEvent();
+    virtual Bool_t   RewindEvents();
+
     virtual Int_t    CheckData() const;
 
   protected :
     virtual Bool_t   ReadNext(UChar_t* data, Int_t size);
 
     TFile*           fFile;         // raw data root file
+    TBranch*         fBranch;       // branch of raw events
+    Int_t            fEventIndex;   // index of the event in the tree
     AliRawEvent*     fEvent;        // (super) event
     Int_t            fSubEventIndex; // index of current sub event
     AliRawEvent*     fSubEvent;     // current sub event