support multiple equipments per sub event in the root raw data format
authortkuhr <tkuhr@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 6 Jul 2004 16:47:25 +0000 (16:47 +0000)
committertkuhr <tkuhr@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 6 Jul 2004 16:47:25 +0000 (16:47 +0000)
RAW/AliMDC.cxx
RAW/AliRawEquipment.cxx [new file with mode: 0644]
RAW/AliRawEquipment.h [new file with mode: 0644]
RAW/AliRawEvent.cxx
RAW/AliRawEvent.h
RAW/AliRawReaderRoot.cxx
RAW/AliRawReaderRoot.h
RAW/LinkDef.h
RAW/Make-macros
RAW/RAWLinkDef.h [new file with mode: 0644]
RAW/libRAW.pkg

index ffc81bd..fd5add6 100644 (file)
@@ -61,6 +61,7 @@
 
 #include "AliRawEvent.h"
 #include "AliRawEventHeader.h"
+#include "AliRawEquipment.h"
 #include "AliRawEquipmentHeader.h"
 #include "AliRawData.h"
 #include "AliStats.h"
@@ -390,33 +391,12 @@ Int_t AliMDC::Run()
 
          Int_t rawSize = subHeader.GetEventSize() - subHeader.HeaderSize();
 
-         // Read Equipment Header (in case of physics or calibration event)
-         if (header.GetType() == AliRawEventHeader::kPhysicsEvent ||
-             header.GetType() == AliRawEventHeader::kCalibrationEvent) {
-            AliRawEquipmentHeader &equipment = *subEvent->GetEquipmentHeader();
-            Int_t equipHeaderSize = equipment.HeaderSize();
-            if ((status = ReadEquipmentHeader(equipment, header.DataIsSwapped(),
-                                              ebdata)) != equipHeaderSize) {
-               if (status == 0) {
-                  Error("Run", "unexpected EOF reading equipment-header");
-                  break;
-               }
-               return 1;
-            }
-            toRead  -= equipHeaderSize;
-            rawSize -= equipHeaderSize;
-#ifdef USE_EB
-            ebdata = (char *)(ebvec[nsub].iov_base) + subHeader.HeaderSize() +
-                     equipHeaderSize;
-#endif
-         }
-
          // Make sure raw data less than left over bytes for current event
          if (rawSize > toRead) {
             ALIDEBUG(1) {
-               Warning("Run", "raw data size (%d) exceeds number of bytes "
-                      "to read (%d)\n", rawSize, toRead);
-              subHeader.Dump();
+               Warning("Run", "raw data size (%d) exceeds number of "
+                      "bytes to read (%d)\n", rawSize, toRead);
+               subHeader.Dump();
             }
             if ((status = DumpEvent(toRead)) != toRead) {
                if (status == 0)
@@ -427,28 +407,79 @@ Int_t AliMDC::Run()
             continue;
          }
 
-         // Read sub-event raw data
-         AliRawData &subRaw = *subEvent->GetRawData();
-         if ((status = ReadRawData(subRaw, rawSize, ebdata)) != rawSize) {
-            if (status == 0) {
-               Error("Run", "unexpected EOF reading sub-event raw data");
-               break;
-            }
-            return 1;
-         }
+         // Read Equipment Headers (in case of physics or calibration event)
+         if (header.GetType() == AliRawEventHeader::kPhysicsEvent ||
+             header.GetType() == AliRawEventHeader::kCalibrationEvent) {
+            while (rawSize > 0) {
+               AliRawEquipment &equipment = *subEvent->NextEquipment();
+               AliRawEquipmentHeader &equipmentHeader = 
+                  *equipment.GetEquipmentHeader();
+               Int_t equipHeaderSize = equipmentHeader.HeaderSize();
+               if ((status = ReadEquipmentHeader(equipmentHeader, header.DataIsSwapped(),
+                                                 ebdata)) != equipHeaderSize) {
+                  if (status == 0) {
+                     Error("Run", "unexpected EOF reading equipment-header");
+                     break;
+                  }
+                  return 1;
+               }
+               toRead  -= equipHeaderSize;
+               rawSize -= equipHeaderSize;
+#ifdef USE_EB
+               ebdata = (char *)(ebvec[nsub].iov_base) +
+                        subHeader.HeaderSize() + equipHeaderSize;
+#endif
+
+               // Read equipment raw data
+               AliRawData &subRaw = *equipment.GetRawData();
+              Int_t eqSize = equipmentHeader.GetEquipmentSize() -
+                              equipHeaderSize;
+               if ((status = ReadRawData(subRaw, eqSize, ebdata)) != eqSize) {
+                  if (status == 0) {
+                     Error("Run", "unexpected EOF reading sub-event raw data");
+                     break;
+                  }
+                  return 1;
+               }
+               toRead  -= eqSize;
+               rawSize -= eqSize;
 
-         if (callFilter) {
+               if (callFilter) {
 #ifdef ALI_DATE
-            if (TEST_USER_ATTRIBUTE(subHeader.GetTypeAttribute(), 0))
-               Filter(subRaw);
-            else {
-               // set size of all sectors without hard track flag to 0
-               subRaw.SetSize(0);
+                  if (TEST_USER_ATTRIBUTE(subHeader.GetTypeAttribute(), 0))
+                     Filter(subRaw);
+                  else {
+                     // set size of all sectors without hard track flag to 0
+                     subRaw.SetSize(0);
+                  }
+#endif
+               }
+           }
+
+         } else {  // Read only raw data but no equipment header
+            AliRawEquipment &equipment = *subEvent->NextEquipment();
+            AliRawData &subRaw = *equipment.GetRawData();
+            if ((status = ReadRawData(subRaw, rawSize, ebdata)) != rawSize) {
+               if (status == 0) {
+                  Error("Run", "unexpected EOF reading sub-event raw data");
+                  break;
+               }
+               return 1;
             }
+            toRead  -= rawSize;
+
+            if (callFilter) {
+#ifdef ALI_DATE
+               if (TEST_USER_ATTRIBUTE(subHeader.GetTypeAttribute(), 0))
+                  Filter(subRaw);
+               else {
+                  // set size of all sectors without hard track flag to 0
+                  subRaw.SetSize(0);
+               }
 #endif
-         }
+            }
+        }
 
-         toRead -= rawSize;
          nsub++;
       }
 
diff --git a/RAW/AliRawEquipment.cxx b/RAW/AliRawEquipment.cxx
new file mode 100644 (file)
index 0000000..1855146
--- /dev/null
@@ -0,0 +1,117 @@
+// @(#)alimdc:$Name$:$Id$
+// Author: Fons Rademakers  26/11/99
+
+/**************************************************************************
+ * Copyright(c) 1998-2003, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// AliRawEvent                                                          //
+//                                                                      //
+// Set of classes defining the ALICE RAW event format. The AliRawEvent  //
+// class defines a RAW event. It consists of an AliEventHeader object   //
+// an AliEquipmentHeader object, an AliRawData object and an array of   //
+// sub-events, themselves also being AliRawEvents. The number of        //
+// sub-events depends on the number of DATE LDC's.                      //
+// The AliRawEvent objects are written to a ROOT file using different   //
+// technologies, i.e. to local disk via AliRawDB or via rfiod using     //
+// AliRawRFIODB or via rootd using AliRawRootdDB or to CASTOR via       //
+// rootd using AliRawCastorDB (and for performance testing there is     //
+// also AliRawNullDB).                                                  //
+// The AliRunDB class provides the interface to the run and file        //
+// catalogues (AliEn or plain MySQL).                                   //
+// The AliStats class provides statics information that is added as     //
+// a single keyed object to each raw file.                              //
+// The AliTagDB provides an interface to a TAG database.                //
+// The AliMDC class is usid by the "alimdc" stand-alone program         //
+// that reads data directly from DATE.                                  //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+
+#include "AliRawEquipmentHeader.h"
+#include "AliRawData.h"
+
+#include "AliRawEquipment.h"
+
+
+ClassImp(AliRawEquipment)
+
+
+//______________________________________________________________________________
+AliRawEquipment::AliRawEquipment()
+{
+   // Create ALICE equipment object.
+
+   fEqpHdr     = 0;
+   fRawData    = 0;
+}
+
+//______________________________________________________________________________
+AliRawEquipment::AliRawEquipment(const AliRawEquipment& rawEquipment): TObject(rawEquipment)
+{
+// copy constructor
+
+  Fatal("AliRawEquipment", "copy constructor not implemented");
+}
+
+//______________________________________________________________________________
+AliRawEquipment& AliRawEquipment::operator = (const AliRawEquipment& /*rawEquipment*/)
+{
+// assignment operator
+
+  Fatal("operator =", "assignment operator not implemented");
+  return *this;
+}
+
+//______________________________________________________________________________
+AliRawEquipmentHeader *AliRawEquipment::GetEquipmentHeader()
+{
+   // Get equipment header part of AliRawEquipment.
+
+   if (!fEqpHdr)
+      fEqpHdr = new AliRawEquipmentHeader;
+
+   return fEqpHdr;
+}
+
+//______________________________________________________________________________
+AliRawData *AliRawEquipment::GetRawData()
+{
+   // Get raw data part of AliRawEquipment.
+
+   if (!fRawData)
+      fRawData = new AliRawData;
+
+   return fRawData;
+}
+
+//______________________________________________________________________________
+void AliRawEquipment::Reset()
+{
+   // Reset the equipment in case it needs to be re-used (avoiding costly
+   // new/delete cycle). We reset the size marker for the AliRawData
+   // object.
+
+   GetRawData()->SetSize(0);
+}
+
+//______________________________________________________________________________
+AliRawEquipment::~AliRawEquipment()
+{
+   // Clean up event object. Delete also, possible, private raw data.
+
+   delete fEqpHdr;
+   delete fRawData;
+}
diff --git a/RAW/AliRawEquipment.h b/RAW/AliRawEquipment.h
new file mode 100644 (file)
index 0000000..b0dfd1d
--- /dev/null
@@ -0,0 +1,64 @@
+#ifndef ALIRAWEQUIPMENT_H
+#define ALIRAWEQUIPMENT_H
+// @(#)alimdc:$Name$:$Id$
+// Author: Fons Rademakers  26/11/99
+// Updated: Dario Favretto  15/04/2003
+
+/* Copyright(c) 1998-2003, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// AliRawEvent                                                          //
+//                                                                      //
+// Set of classes defining the ALICE RAW event format. The AliRawEvent  //
+// class defines a RAW event. It consists of an AliEventHeader object   //
+// an AliEquipmentHeader object, an AliRawData object and an array of   //
+// sub-events, themselves also being AliRawEvents. The number of        //
+// sub-events depends on the number of DATE LDC's.                      //
+// The AliRawEvent objects are written to a ROOT file using different   //
+// technologies, i.e. to local disk via AliRawDB or via rfiod using     //
+// AliRawRFIODB or via rootd using AliRawRootdDB or to CASTOR via       //
+// rootd using AliRawCastorDB (and for performance testing there is     //
+// also AliRawNullDB).                                                  //
+// The AliRunDB class provides the interface to the run and file        //
+// catalogues (AliEn or plain MySQL).                                   //
+// The AliStats class provides statics information that is added as     //
+// a single keyed object to each raw file.                              //
+// The AliTagDB provides an interface to a TAG database.                //
+// The AliMDC class is usid by the "alimdc" stand-alone program         //
+// that reads data directly from DATE.                                  //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+
+#ifndef ROOT_TObject
+#include <TObject.h>
+#endif
+
+
+// Forward class declarations
+class AliRawEquipmentHeader;
+class AliRawData;
+
+
+class AliRawEquipment : public TObject {
+
+public:
+   AliRawEquipment();
+   virtual ~AliRawEquipment();
+
+   AliRawEquipmentHeader *GetEquipmentHeader();
+   AliRawData            *GetRawData();
+   void                   Reset();
+
+private:
+   AliRawEquipmentHeader *fEqpHdr;      // equipment header
+   AliRawData            *fRawData;     // raw data container
+
+   AliRawEquipment(const AliRawEquipment& rawEvent);
+   AliRawEquipment& operator = (const AliRawEquipment& rawEvent);
+
+   ClassDef(AliRawEquipment,1)  // ALICE raw equipment object
+};
+
+#endif
index 7cd1e81..e5fa3cf 100644 (file)
@@ -43,8 +43,7 @@
 #include <TObjArray.h>
 
 #include "AliRawEventHeader.h"
-#include "AliRawEquipmentHeader.h"
-#include "AliRawData.h"
+#include "AliRawEquipment.h"
 
 #include "AliRawEvent.h"
 
@@ -58,11 +57,11 @@ AliRawEvent::AliRawEvent()
    // Create ALICE event object. If ownData is kFALSE we will use a static
    // raw data object, otherwise a private copy will be made.
 
-   fNSubEvents = 0;
-   fEvtHdr     = 0;
-   fEqpHdr     = 0;
-   fRawData    = 0;
-   fSubEvents  = 0;
+   fNEquipments = 0;
+   fNSubEvents  = 0;
+   fEvtHdr      = 0;
+   fEquipments  = 0;
+   fSubEvents   = 0;
 }
 
 //______________________________________________________________________________
@@ -94,25 +93,39 @@ AliRawEventHeader *AliRawEvent::GetHeader()
 }
 
 //______________________________________________________________________________
-AliRawEquipmentHeader *AliRawEvent::GetEquipmentHeader()
+AliRawEquipment *AliRawEvent::NextEquipment()
 {
-   // Get equipment header part of AliRawEvent.
+   // Returns next equipment object.
+
+   if (!fEquipments)
+      fEquipments = new TObjArray(100); // arbitrary, probably enough to prevent resizing
+
+   if (fEquipments->GetSize() <= fNEquipments) {
+      fEquipments->Expand(fNEquipments+10);
+      Warning("NextEquipment", "expanded fEquipments by 10 to %d",
+              fEquipments->GetSize());
+   }
 
-   if (!fEqpHdr)
-      fEqpHdr = new AliRawEquipmentHeader;
+   AliRawEquipment *eq;
+   if (!(eq = (AliRawEquipment *)fEquipments->At(fNEquipments))) {
+      eq = new AliRawEquipment;
+      fEquipments->AddAt(eq, fNEquipments);
+   }
+
+   fNEquipments++;
 
-   return fEqpHdr;
+   return eq;
 }
 
 //______________________________________________________________________________
-AliRawData *AliRawEvent::GetRawData()
+AliRawEquipment *AliRawEvent::GetEquipment(Int_t index) const
 {
-   // Get raw data part of AliRawEvent.
+   // Get specified equipment. Returns 0 if equipment does not exist.
 
-   if (!fRawData)
-      fRawData = new AliRawData;
+   if (!fEquipments)
+      return 0;
 
-   return fRawData;
+   return (AliRawEquipment *) fEquipments->At(index);
 }
 
 //______________________________________________________________________________
@@ -158,9 +171,14 @@ void AliRawEvent::Reset()
    // new/delete cycle). We reset the size marker for the AliRawData
    // objects and the sub event counter.
 
+   for (int i = 0; i < fNEquipments; i++) {
+      AliRawEquipment *eq = (AliRawEquipment *)fEquipments->At(i);
+      eq->Reset();
+   }
+   fNEquipments = 0;
    for (int i = 0; i < fNSubEvents; i++) {
       AliRawEvent *ev = (AliRawEvent *)fSubEvents->At(i);
-      ev->GetRawData()->SetSize(0);
+      ev->Reset();
    }
    fNSubEvents = 0;
 }
@@ -171,8 +189,9 @@ AliRawEvent::~AliRawEvent()
    // Clean up event object. Delete also, possible, private raw data.
 
    delete fEvtHdr;
-   delete fEqpHdr;
-   delete fRawData;
+   if (fEquipments)
+      fEquipments->Delete();
+   delete fEquipments;
    if (fSubEvents)
       fSubEvents->Delete();
    delete fSubEvents;
index 76db858..a6133ca 100644 (file)
@@ -38,8 +38,7 @@
 
 // Forward class declarations
 class AliRawEventHeader;
-class AliRawEquipmentHeader;
-class AliRawData;
+class AliRawEquipment;
 
 
 class AliRawEvent : public TObject {
@@ -49,24 +48,25 @@ public:
    virtual ~AliRawEvent();
 
    AliRawEventHeader     *GetHeader();
-   AliRawEquipmentHeader *GetEquipmentHeader();
-   AliRawData            *GetRawData();
+   Int_t                  GetNEquipments() const { return fNEquipments; }
+   AliRawEquipment       *NextEquipment();
+   AliRawEquipment       *GetEquipment(Int_t index) const;
    Int_t                  GetNSubEvents() const { return fNSubEvents; }
    AliRawEvent           *NextSubEvent();
    AliRawEvent           *GetSubEvent(Int_t index) const;
    void                   Reset();
 
 private:
+   Int_t                  fNEquipments; // number of valid equipments
    Int_t                  fNSubEvents;  // number of valid sub-events
    AliRawEventHeader     *fEvtHdr;      // event header object
-   AliRawEquipmentHeader *fEqpHdr;      // equipment header
-   AliRawData            *fRawData;     // raw data container
+   TObjArray             *fEquipments;  // AliRawEquipment's
    TObjArray             *fSubEvents;   // sub AliRawEvent's
 
    AliRawEvent(const AliRawEvent& rawEvent);
    AliRawEvent& operator = (const AliRawEvent& rawEvent);
 
-   ClassDef(AliRawEvent,1)  // ALICE raw event object
+   ClassDef(AliRawEvent,2)  // ALICE raw event object
 };
 
 #endif
index c963e33..b458c75 100644 (file)
@@ -33,6 +33,7 @@
 #include "AliRawReaderRoot.h"
 #include "AliRawEvent.h"
 #include "AliRawEventHeader.h"
+#include "AliRawEquipment.h"
 #include "AliRawEquipmentHeader.h"
 #include "AliRawData.h"
 
@@ -47,6 +48,8 @@ AliRawReaderRoot::AliRawReaderRoot(const char* fileName, Int_t eventNumber) :
   fEvent(NULL),
   fSubEventIndex(0),
   fSubEvent(NULL),
+  fEquipmentIndex(0),
+  fEquipment(NULL),
   fRawData(NULL),
   fPosition(NULL),
   fEnd(NULL)
@@ -89,6 +92,8 @@ AliRawReaderRoot::AliRawReaderRoot(AliRawEvent* event) :
   fEvent(event),
   fSubEventIndex(0),
   fSubEvent(NULL),
+  fEquipmentIndex(0),
+  fEquipment(NULL),
   fRawData(NULL),
   fPosition(NULL),
   fEnd(NULL)
@@ -105,6 +110,8 @@ AliRawReaderRoot::AliRawReaderRoot(const AliRawReaderRoot& rawReader) :
   fEvent(NULL),
   fSubEventIndex(rawReader.fSubEventIndex),
   fSubEvent(NULL),
+  fEquipmentIndex(rawReader.fEquipmentIndex),
+  fEquipment(NULL),
   fRawData(NULL),
   fPosition(NULL),
   fEnd(NULL)
@@ -146,7 +153,8 @@ AliRawReaderRoot::AliRawReaderRoot(const AliRawReaderRoot& rawReader) :
 
   if (fSubEventIndex > 0) {
     fSubEvent = fEvent->GetSubEvent(fSubEventIndex-1);
-    fRawData = fSubEvent->GetRawData();
+    fEquipment = fSubEvent->GetEquipment(fEquipmentIndex);
+    fRawData = fEquipment->GetRawData();
       fCount = 0;
     fHeader = (AliRawDataHeader*) ((UChar_t*) fRawData->GetBuffer() + 
       ((UChar_t*) rawReader.fHeader - 
@@ -231,8 +239,8 @@ UInt_t AliRawReaderRoot::GetLDCId() const
 {
 // get the LDC Id from the event header
 
-  if (!fEvent || !fEvent->GetSubEvent(fSubEventIndex)) return 0;
-  return fEvent->GetSubEvent(fSubEventIndex)->GetHeader()->GetLDCId();
+  if (!fEvent || !fSubEvent) return 0;
+  return fSubEvent->GetHeader()->GetLDCId();
 }
 
 UInt_t AliRawReaderRoot::GetGDCId() const
@@ -248,40 +256,40 @@ Int_t AliRawReaderRoot::GetEquipmentSize() const
 {
 // get the size of the equipment
 
-  if (!fEvent || !fEvent->GetEquipmentHeader()) return 0;
-  return fEvent->GetEquipmentHeader()->GetEquipmentSize();
+  if (!fEvent || !fEquipment || !fEquipment->GetEquipmentHeader()) return 0;
+  return fEquipment->GetEquipmentHeader()->GetEquipmentSize();
 }
 
 Int_t AliRawReaderRoot::GetEquipmentType() const
 {
 // get the type from the equipment header
 
-  if (!fEvent || !fEvent->GetEquipmentHeader()) return -1;
-  return fEvent->GetEquipmentHeader()->GetEquipmentType();
+  if (!fEvent || !fEquipment || !fEquipment->GetEquipmentHeader()) return -1;
+  return fEquipment->GetEquipmentHeader()->GetEquipmentType();
 }
 
 Int_t AliRawReaderRoot::GetEquipmentId() const
 {
 // get the ID from the equipment header
 
-  if (!fEvent || !fEvent->GetEquipmentHeader()) return -1;
-  return fEvent->GetEquipmentHeader()->GetId();
+  if (!fEvent || !fEquipment || !fEquipment->GetEquipmentHeader()) return -1;
+  return fEquipment->GetEquipmentHeader()->GetId();
 }
 
 const UInt_t* AliRawReaderRoot::GetEquipmentAttributes() const
 {
 // get the attributes from the equipment header
 
-  if (!fEvent || !fEvent->GetEquipmentHeader()) return NULL;
-  return fEvent->GetEquipmentHeader()->GetTypeAttribute();
+  if (!fEvent || !fEquipment || !fEquipment->GetEquipmentHeader()) return NULL;
+  return fEquipment->GetEquipmentHeader()->GetTypeAttribute();
 }
 
 Int_t AliRawReaderRoot::GetEquipmentElementSize() const
 {
 // get the basic element size from the equipment header
 
-  if (!fEvent || !fEvent->GetEquipmentHeader()) return 0;
-  return fEvent->GetEquipmentHeader()->GetBasicSizeType();
+  if (!fEvent || !fEquipment || !fEquipment->GetEquipmentHeader()) return 0;
+  return fEquipment->GetEquipmentHeader()->GetBasicSizeType();
 }
 
 
@@ -297,35 +305,50 @@ Bool_t AliRawReaderRoot::ReadHeader()
     // skip payload (if event was not selected)
     if (fCount > 0) fPosition += fCount;
 
-    // get the first or the next sub event if at the end of a sub event
-    if (!fSubEvent || (fPosition >= fEnd)) {
+    // get the first or the next equipment if at the end of an equipment
+    if (!fEquipment || (fPosition >= fEnd)) {
 
-      // check for end of event data
-      if (fSubEventIndex >= fEvent->GetNSubEvents()) return kFALSE;
-      fSubEvent = fEvent->GetSubEvent(fSubEventIndex++);
+      // get the first or the next sub event if at the end of a sub event
+      if (!fSubEvent || (fEquipmentIndex >= fSubEvent->GetNEquipments())) {
 
-      // check the magic word of the sub event
-      if (!fSubEvent->GetHeader()->IsValid()) {
-       Error("ReadHeader", "wrong magic number in sub event!");
-       fSubEvent->GetHeader()->Dump();
-       fErrorCode = kErrMagic;
-       return kFALSE;
+       // check for end of event data
+       if (fSubEventIndex >= fEvent->GetNSubEvents()) return kFALSE;
+       fSubEvent = fEvent->GetSubEvent(fSubEventIndex++);
+
+       // check the magic word of the sub event
+       if (!fSubEvent->GetHeader()->IsValid()) {
+         Error("ReadHeader", "wrong magic number in sub event!");
+         fSubEvent->GetHeader()->Dump();
+         fErrorCode = kErrMagic;
+         return kFALSE;
+       }
+
+       fEquipmentIndex = 0;
+       fEquipment = NULL;
+       fRawData = NULL;
       }
 
-      fRawData = fSubEvent->GetRawData();
+      // get the next equipment and raw data
       fCount = 0;
+      fEquipment = fSubEvent->GetEquipment(fEquipmentIndex++);
+      if (!fEquipment) continue;
+      fRawData = fEquipment->GetRawData();
+      if (!fRawData) {
+       fPosition = fEnd;
+       continue;
+      }
       fPosition = (UChar_t*) fRawData->GetBuffer();
       fEnd = ((UChar_t*) fRawData->GetBuffer()) + fRawData->GetSize();
     }
 
-    // continue with the next sub event if no data left in the payload
+    // 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);
-      fSubEvent->GetHeader()->Dump();
+      fEquipment->GetEquipmentHeader()->Dump();
       fCount = 0;
       fPosition = fEnd;
       fErrorCode = kErrNoDataHeader;
@@ -345,7 +368,7 @@ Bool_t AliRawReaderRoot::ReadHeader()
     if (fPosition + fCount > fEnd) {  
       Error("ReadHeader", "size in data header exceeds event size!");
       Warning("ReadHeader", "skipping %d bytes", fEnd - fPosition);
-      fSubEvent->GetHeader()->Dump();
+      fEquipment->GetEquipmentHeader()->Dump();
       fCount = 0;
       fPosition = fEnd;
       fErrorCode = kErrSize;
@@ -396,6 +419,8 @@ Bool_t AliRawReaderRoot::Reset()
 
   fSubEventIndex = 0;
   fSubEvent = NULL;
+  fEquipmentIndex = 0;
+  fEquipment = NULL;
   fRawData = NULL;
   fHeader = NULL;
 
@@ -445,13 +470,15 @@ Int_t AliRawReaderRoot::CheckData() const
 
   AliRawEvent* subEvent = NULL;
   Int_t subEventIndex = 0;
+  AliRawEquipment* equipment = NULL;
+  Int_t equipmentIndex = 0;
   UChar_t* position = 0;
   UChar_t* end = 0;
   Int_t result = 0;
 
   while (kTRUE) {
-    // get the first or the next sub event if at the end of a sub event
-    if (!subEvent || (position >= end)) {
+    // get the first or the next sub event if at the end of an equipment
+    if (!subEvent || (equipmentIndex >= subEvent->GetNEquipments())) {
 
       // check for end of event data
       if (subEventIndex >= fEvent->GetNSubEvents()) return result;
@@ -463,32 +490,32 @@ Int_t AliRawReaderRoot::CheckData() const
        return result;
       }
 
-      AliRawData* rawData = subEvent->GetRawData();
-      position = (UChar_t*) rawData->GetBuffer();
-      end = ((UChar_t*) rawData->GetBuffer()) + rawData->GetSize();
+      equipmentIndex = 0;
     }
 
+    // get the next equipment and raw data
+    equipment = subEvent->GetEquipment(equipmentIndex++);
+    if (!equipment) continue;
+    AliRawData* rawData = equipment->GetRawData();
+    if (!rawData) continue;
+    position = (UChar_t*) rawData->GetBuffer();
+    end = ((UChar_t*) rawData->GetBuffer()) + rawData->GetSize();
+
     // continue with the next sub event if no data left in the payload
     if (position >= end) continue;
 
     // check that there are enough bytes left for the data header
     if (position + sizeof(AliRawDataHeader) > end) {
       result |= kErrNoDataHeader;
-      position = end;
       continue;
     }
 
-    // check consistency of data size in the header and in the sub event
+    // check consistency of data size in the header and in the equipment
     AliRawDataHeader* header = (AliRawDataHeader*) position;
-    if (fHeader->fSize != 0xFFFFFFFF) {
+    if (header->fSize != 0xFFFFFFFF) {
       if (position + header->fSize > end) {
        result |= kErrSize;
-       position = end;
-      } else {
-       position += header->fSize;
       }
-    } else {
-      position = end;
     }
   };
 
index e300eb0..e9bc451 100644 (file)
@@ -14,6 +14,7 @@
 #include "AliRawReader.h"
 
 class AliRawEvent;
+class AliRawEquipment;
 class AliRawData;
 class TFile;
 class TBranch;
@@ -61,6 +62,8 @@ class AliRawReaderRoot: public AliRawReader {
     AliRawEvent*     fEvent;        // (super) event
     Int_t            fSubEventIndex; // index of current sub event
     AliRawEvent*     fSubEvent;     // current sub event
+    Int_t            fEquipmentIndex; // index of current equipment
+    AliRawEquipment* fEquipment;    // current equipment
     AliRawData*      fRawData;      // current raw data
     UChar_t*         fPosition;     // current position in the raw data
     UChar_t*         fEnd;          // end position of the current subevent
index 3f40a2e..6e6c527 100644 (file)
@@ -7,6 +7,7 @@
 #pragma link C++ class AliRawEvent;
 #pragma link C++ class AliRawEventHeader;
 #pragma link C++ class AliRawEquipmentHeader;
+#pragma link C++ class AliRawEquipment;
 #pragma link C++ class AliRawData;
 #pragma link C++ class AliStats;
 #pragma link C++ class AliRawDB;
 #pragma link C++ class AliTagNullDB;
 #pragma link C++ class AliRunDB;
 #pragma link C++ class AliMDC;
-#pragma link C++ class AliRawReader+;
-#pragma link C++ class AliRawReaderFile+;
-#pragma link C++ class AliRawReaderRoot+;
-#pragma link C++ class AliRawReaderDate+;
-#pragma link C++ class AliBitPacking+;
-#pragma link C++ class AliAltroBuffer+;
-#pragma link C++ class AliTPCCompression+;
-#pragma link C++ class AliTPCHNode+;
-#pragma link C++ class AliTPCHTable+;
-#pragma link C++ class AliAltroRawStream+;
-#pragma link C++ class AliTPCRawStream+;
-#pragma link C++ class AliITSRawStream+;
-#pragma link C++ class AliITSRawStreamSPD+;
-#pragma link C++ class AliITSRawStreamSDD+;
-#pragma link C++ class AliITSRawStreamSSD+;
-#pragma link C++ class AliITSRawStreamSDDv2+;
-#pragma link C++ class AliVMERawStream+;
 
 #endif
index b1864d7..9d43db8 100644 (file)
@@ -3,18 +3,11 @@
 ROOTH         = TH1.h
 
 SRCS          = AliRawEventHeader.cxx AliRawEquipmentHeader.cxx \
-               AliRawData.cxx AliRawEvent.cxx \
+               AliRawData.cxx AliRawEquipment.cxx AliRawEvent.cxx \
                AliStats.cxx AliRawDB.cxx \
                AliRawRFIODB.cxx AliRawCastorDB.cxx AliRawRootdDB.cxx \
                AliRawNullDB.cxx AliTagDB.cxx AliTagNullDB.cxx \
-               AliRunDB.cxx AliMDC.cxx \
-               AliRawReader.cxx AliRawReaderFile.cxx AliRawReaderRoot.cxx \
-               AliRawReaderDate.cxx AliTPCBuffer160.cxx \
-               AliTPCHNode.cxx AliTPCHTable.cxx \
-               AliTPCCompression.cxx AliTPCRawStream.cxx \
-               AliITSRawStream.cxx AliITSRawStreamSPD.cxx \
-               AliITSRawStreamSDD.cxx AliITSRawStreamSSD.cxx \
-               AliITSRawStreamSDDv2.cxx AliVMERawStream.cxx
+               AliRunDB.cxx AliMDC.cxx
 
 HDRS          = $(SRCS:.cxx=.h) LinkDef.h
 
@@ -31,7 +24,6 @@ ALLDICT       = $(DICT) $(DICTH)
 ALLSRCS       = $(SRCS) $(HDRS) $(MAIN)
 ALLOBJS       = $(OBJS) $(MAINO)
 
-ALIRAW        = libRAW.so
 ALIMDC        = alimdc
 
 
@@ -47,40 +39,20 @@ ALIMDC        = alimdc
 
 ##### TARGETS #####
 
-all:            $(ALIRAW) $(ALIMDC)
+all:            $(ALIMDC)
 
-rdm:            $(ALIRAW) $(ALIMDC)
+rdm:            $(ALIMDC)
 
-smi:            $(ALIRAW) $(ALIMDC)
+smi:            $(ALIMDC)
 
-evb:            $(ALIRAW) $(ALIMDC)
+evb:            $(ALIMDC)
 
-hlt:            $(ALIRAW) $(ALIMDC)
+hlt:            $(ALIMDC)
 
-$(ALIRAW):      $(DICT) $(OBJS)
-               rm -f $(ALIRAW)
-                ifeq ($(ALICE_PLATFORM),aix)
-                  $(SHLD) -o $(ALIRAW) $(LIBS) -p 0 $(OBJS)
-                else
-                   ifeq ($(ALICE_PLATFORM),alpha)
-                     $(SHLD) -o $(ALIRAW) $(OBJS) -lcxxstd -lcxx -lexc -lots -lc
-                   else
-                     $(LD) $(SOFLAGS) $(LDFLAGS) $(OBJS) -o $(ALIRAW)
-                   endif
-                endif
-               chmod 555 $(ALIRAW)
-               @echo "$(ALIRAW) done"
 
-
-$(ALIMDC):      $(MAINO) $(ALIRAW)
-                ifeq ($(ALICE_PLATFORM),aix)
-                  ln -fs $(ALILRAW) libAliRaw.a
-                  $(LD) $(LDFLAGS) $(MAINO) libAliRaw.a \
-                  $(LIBS) -o $(ALIMDC)
-                else
-                  $(LD) $(LDFLAGS) $(MAINO) $(ALIRAW) \
-                  $(LIBS) -o $(ALIMDC)
-                endif
+$(ALIMDC):      $(MAINO) $(DICT) $(OBJS)
+               $(LD) $(LDFLAGS) $(MAINO) $(OBJS) \
+               $(LIBS) -o $(ALIMDC)
                @if [ `id -u -n` = "alicemdc" ]; then \
                   chmod 6755 alimdc; \
                fi
@@ -105,4 +77,4 @@ clean:
                @rm -f $(ALLOBJS) $(ALLDICT)
 
 distclean:      clean
-               @rm -f $(ALIMDC) $(ALIRAW)
+               @rm -f $(ALIMDC)
diff --git a/RAW/RAWLinkDef.h b/RAW/RAWLinkDef.h
new file mode 100644 (file)
index 0000000..3067d6c
--- /dev/null
@@ -0,0 +1,40 @@
+#ifdef __CINT__
+
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+#pragma link C++ class AliRawEvent;
+#pragma link C++ class AliRawEventHeader;
+#pragma link C++ class AliRawEquipmentHeader;
+#pragma link C++ class AliRawEquipment;
+#pragma link C++ class AliRawData;
+#pragma link C++ class AliStats;
+#pragma link C++ class AliRawDB;
+#pragma link C++ class AliRawRFIODB;
+#pragma link C++ class AliRawCastorDB;
+#pragma link C++ class AliRawRootdDB;
+#pragma link C++ class AliRawNullDB;
+#pragma link C++ class AliTagDB;
+#pragma link C++ class AliTagNullDB;
+#pragma link C++ class AliRunDB;
+#pragma link C++ class AliMDC;
+#pragma link C++ class AliRawReader+;
+#pragma link C++ class AliRawReaderFile+;
+#pragma link C++ class AliRawReaderRoot+;
+#pragma link C++ class AliRawReaderDate+;
+#pragma link C++ class AliBitPacking+;
+#pragma link C++ class AliAltroBuffer+;
+#pragma link C++ class AliTPCCompression+;
+#pragma link C++ class AliTPCHNode+;
+#pragma link C++ class AliTPCHTable+;
+#pragma link C++ class AliAltroRawStream+;
+#pragma link C++ class AliTPCRawStream+;
+#pragma link C++ class AliITSRawStream+;
+#pragma link C++ class AliITSRawStreamSPD+;
+#pragma link C++ class AliITSRawStreamSDD+;
+#pragma link C++ class AliITSRawStreamSSD+;
+#pragma link C++ class AliITSRawStreamSDDv2+;
+#pragma link C++ class AliVMERawStream+;
+
+#endif
index b28912b..07c506e 100644 (file)
@@ -1,5 +1,5 @@
 SRCS:=  AliRawEventHeader.cxx AliRawEquipmentHeader.cxx \
-       AliRawData.cxx AliRawEvent.cxx \
+       AliRawData.cxx AliRawEquipment.cxx AliRawEvent.cxx \
        AliStats.cxx AliRawDB.cxx \
        AliRawRFIODB.cxx AliRawCastorDB.cxx AliRawRootdDB.cxx \
        AliRawNullDB.cxx AliTagDB.cxx AliTagNullDB.cxx \
@@ -19,7 +19,7 @@ EHDRS:=$(ROOTSYS)/include/TH1F.h
 
 EDEFINE:= -DUSE_RDM
 
-DHDR:= LinkDef.h 
+DHDR:= RAWLinkDef.h 
 
 ifdef DATE_ROOT
 EINCLUDE+= ${DATE_COMMON_DEFS}