New raw data versioning scheme.
authorcvetan <cvetan@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 24 Oct 2005 14:48:50 +0000 (14:48 +0000)
committercvetan <cvetan@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 24 Oct 2005 14:48:50 +0000 (14:48 +0000)
18 files changed:
RAW/AliMDC.cxx
RAW/AliMDC.h
RAW/AliRawDB.cxx
RAW/AliRawEvent.cxx
RAW/AliRawEvent.h
RAW/AliRawEventHeader.cxx [deleted file]
RAW/AliRawEventHeader.h [deleted file]
RAW/AliRawEventHeaderBase.cxx [new file with mode: 0644]
RAW/AliRawEventHeaderBase.h [new file with mode: 0644]
RAW/AliRawEventHeaderVersions.h [new file with mode: 0644]
RAW/AliRawReaderRoot.cxx
RAW/AliStats.cxx
RAW/AliTagDB.cxx
RAW/AliTagDB.h
RAW/AliTagNullDB.cxx
RAW/AliTagNullDB.h
RAW/RAWLinkDef.h
RAW/libRAWData.pkg

index 19a6d5e..e8734c1 100644 (file)
@@ -61,7 +61,7 @@
 #include <AliESD.h>
 
 #include "AliRawEvent.h"
-#include "AliRawEventHeader.h"
+#include "AliRawEventHeaderBase.h"
 #include "AliRawEquipment.h"
 #include "AliRawEquipmentHeader.h"
 #include "AliRawData.h"
@@ -98,7 +98,10 @@ AliMDC::AliMDC(Int_t compress, Bool_t deleteFiles, EFilterMode filterMode,
   fDeleteFiles(deleteFiles),
   fFilterMode(filterMode),
   fFilters(),
-  fStop(kFALSE)
+  fStop(kFALSE),
+  fIsTagDBCreated(kFALSE),
+  fMaxSizeTagDB(maxSizeTagDB),
+  fFileNameTagDB(fileNameTagDB)
 {
   // Create MDC processor object.
   // compress is the file compression mode.
@@ -123,16 +126,18 @@ AliMDC::AliMDC(Int_t compress, Bool_t deleteFiles, EFilterMode filterMode,
     fESD = new AliESD;
   }
 
-  if (fileNameTagDB) {
-    if (maxSizeTagDB > 0) {
-      fTagDB = new AliTagDB(fEvent->GetHeader(), NULL);
-      fTagDB->SetMaxSize(maxSizeTagDB);
-      fTagDB->SetFS(fileNameTagDB);
-      fTagDB->Create();
-    } else {
-      fTagDB = new AliTagDB(fEvent->GetHeader(), fileNameTagDB);
-    }
-  }
+// Tag DB is now created at the point where the header version is
+// already known
+//   if (fileNameTagDB) {
+//     if (maxSizeTagDB > 0) {
+//       fTagDB = new AliTagDB(fEvent->GetHeader(), NULL);
+//       fTagDB->SetMaxSize(maxSizeTagDB);
+//       fTagDB->SetFS(fileNameTagDB);
+//       fTagDB->Create();
+//     } else {
+//       fTagDB = new AliTagDB(fEvent->GetHeader(), fileNameTagDB);
+//     }
+//   }
 
   // install SIGUSR1 handler to allow clean interrupts
   gSystem->AddSignalHandler(new AliMDCInterruptHandler(this));
@@ -161,7 +166,7 @@ AliMDC::~AliMDC()
 // destructor
 
   fFilters.Delete();
-  delete fTagDB;
+  if(fTagDB) delete fTagDB;
   delete fRunDB;
   delete fRawDB;
   delete fStats;
@@ -240,30 +245,30 @@ Int_t AliMDC::ProcessEvent(void* event, Bool_t isIovecArray)
   if (isIovecArray) data = (char*) ((iovec*) event)[0].iov_base;
 
   // Shortcut for easy header access
-  AliRawEventHeader &header = *fEvent->GetHeader();
+  AliRawEventHeaderBase *header = fEvent->GetHeader(data);
 
   // Read event header
-  if ((status = ReadHeader(header, data)) != header.HeaderSize()) {
+  if ((status = header->ReadHeader(data)) != (Int_t)header->GetHeadSize()) {
     return kErrHeader;
   }
 
-  if (AliDebugLevel() > 2) ToAliDebug(3, header.Dump(););
+  if (AliDebugLevel() > 2) ToAliDebug(3, header->Dump(););
 
   // Check event type and skip "Start of Run", "End of Run",
   // "Start of Run Files" and "End of Run Files"
-  Int_t size = header.GetEventSize() - header.HeaderSize();
-  switch (header.GetType()) {
-  case AliRawEventHeader::kStartOfRun:
-  case AliRawEventHeader::kEndOfRun:
-  case AliRawEventHeader::kStartOfRunFiles:
-  case AliRawEventHeader::kEndOfRunFiles:
+  Int_t size = header->GetEventSize() - header->GetHeadSize();
+  switch (header->Get("Type")) {
+  case AliRawEventHeaderBase::kStartOfRun:
+  case AliRawEventHeaderBase::kEndOfRun:
+  case AliRawEventHeaderBase::kStartOfRunFiles:
+  case AliRawEventHeaderBase::kEndOfRunFiles:
     {
-      AliDebug(1, Form("Skipping %s (%d bytes)", header.GetTypeName(), size));
+      AliDebug(1, Form("Skipping %s (%d bytes)", header->GetTypeName(), size));
       return kErrStartEndRun;
     }
   default:
     {
-      AliDebug(1, Form("Processing %s (%d bytes)", header.GetTypeName(), size));
+      AliDebug(1, Form("Processing %s (%d bytes)", header->GetTypeName(), size));
     }
   }
 
@@ -272,10 +277,10 @@ Int_t AliMDC::ProcessEvent(void* event, Bool_t isIovecArray)
 
   // If there is less data for this event than the next sub-event
   // header, something is wrong. Skip to next event...
-  if (toRead < header.HeaderSize()) {
+  if (toRead < (Int_t)header->GetHeadSize()) {
     Error("ProcessEvent", "header size (%d) exceeds number of bytes "
-         "to read (%d)", header.HeaderSize(), toRead);
-    if (AliDebugLevel() > 0) ToAliDebug(1, header.Dump(););
+         "to read (%d)", header->GetHeadSize(), toRead);
+    if (AliDebugLevel() > 0) ToAliDebug(1, header->Dump(););
     return kErrHeaderSize;
   }
   
@@ -289,34 +294,34 @@ Int_t AliMDC::ProcessEvent(void* event, Bool_t isIovecArray)
     AliRawEvent *subEvent = fEvent->NextSubEvent();
 
     // Read sub-event header
-    AliRawEventHeader &subHeader = *subEvent->GetHeader();
-    if ((status = ReadHeader(subHeader, data)) != subHeader.HeaderSize()) {
+    AliRawEventHeaderBase *subHeader = subEvent->GetHeader(data);
+    if ((status = subHeader->ReadHeader(data)) != (Int_t)subHeader->GetHeadSize()) {
       return kErrSubHeader;
     }
 
-    if (AliDebugLevel() > 2) ToAliDebug(3, subHeader.Dump(););
+    if (AliDebugLevel() > 2) ToAliDebug(3, subHeader->Dump(););
 
-    toRead -= subHeader.HeaderSize();
+    toRead -= subHeader->GetHeadSize();
 
-    Int_t rawSize = subHeader.GetEventSize() - subHeader.HeaderSize();
+    Int_t rawSize = subHeader->GetEventSize() - subHeader->GetHeadSize();
 
     // Make sure raw data less than left over bytes for current event
     if (rawSize > toRead) {
       Warning("ProcessEvent", "raw data size (%d) exceeds number of "
              "bytes to read (%d)\n", rawSize, toRead);
-      if (AliDebugLevel() > 0) ToAliDebug(1, subHeader.Dump(););
+      if (AliDebugLevel() > 0) ToAliDebug(1, subHeader->Dump(););
       return kErrDataSize;
     }
 
     // Read Equipment Headers (in case of physics or calibration event)
-    if (header.GetType() == AliRawEventHeader::kPhysicsEvent ||
-       header.GetType() == AliRawEventHeader::kCalibrationEvent) {
+    if (header->Get("Type") == AliRawEventHeaderBase::kPhysicsEvent ||
+       header->Get("Type") == AliRawEventHeaderBase::kCalibrationEvent) {
       while (rawSize > 0) {
        AliRawEquipment &equipment = *subEvent->NextEquipment();
        AliRawEquipmentHeader &equipmentHeader = 
          *equipment.GetEquipmentHeader();
        Int_t equipHeaderSize = equipmentHeader.HeaderSize();
-       if ((status = ReadEquipmentHeader(equipmentHeader, header.DataIsSwapped(),
+       if ((status = ReadEquipmentHeader(equipmentHeader, header->DataIsSwapped(),
                                          data)) != equipHeaderSize) {
          return kErrEquipmentHeader;
        }
@@ -350,8 +355,8 @@ Int_t AliMDC::ProcessEvent(void* event, Bool_t isIovecArray)
 
   // High Level Event Filter
   if (fFilterMode != kFilterOff) {
-    if (header.GetType() == AliRawEventHeader::kPhysicsEvent ||
-       header.GetType() == AliRawEventHeader::kCalibrationEvent) {
+    if (header->Get("Type") == AliRawEventHeaderBase::kPhysicsEvent ||
+       header->Get("Type") == AliRawEventHeaderBase::kCalibrationEvent) {
       Bool_t result = kFALSE;
       for (Int_t iFilter = 0; iFilter < fFilters.GetEntriesFast(); iFilter++) {
        AliFilter* filter = (AliFilter*) fFilters[iFilter];
@@ -364,11 +369,27 @@ Int_t AliMDC::ProcessEvent(void* event, Bool_t isIovecArray)
 
   // Set stat info for first event of this file
   if (fRawDB->GetEvents() == 0)
-    fStats->SetFirstId(header.GetRunNumber(), header.GetEventInRun());
+    fStats->SetFirstId(header->Get("RunNb"), header->GetP("Id")[0]);
 
   // Store raw event in tree
   Int_t nBytes = fRawDB->Fill();
 
+  // Create Tag DB here only after the raw data header
+  // version was already identified
+  if (!fIsTagDBCreated) {
+    if (fFileNameTagDB) {
+      if (fMaxSizeTagDB > 0) {
+       fTagDB = new AliTagDB(fEvent->GetHeader(), NULL);
+       fTagDB->SetMaxSize(fMaxSizeTagDB);
+       fTagDB->SetFS(fFileNameTagDB);
+       fTagDB->Create();
+      } else {
+       fTagDB = new AliTagDB(fEvent->GetHeader(), fFileNameTagDB);
+      }
+    }
+    fIsTagDBCreated = kTRUE;
+  }
+
   // Store header in tree
   if (fTagDB) fTagDB->Fill();
 
@@ -484,6 +505,8 @@ Int_t AliMDC::Run(const char* inputFile, Bool_t loop,
   UInt_t eventSize = 0;
   Int_t numEvents = 0;
 
+  AliRawEventHeaderBase header;
+
   while (kTRUE) {
 
     // If we were in looping mode stop directly after a SIGUSR1 signal
@@ -514,37 +537,66 @@ Int_t AliMDC::Run(const char* inputFile, Bool_t loop,
 #endif
 
     } else {  // get data from a file
-      AliRawEventHeader header;
+      {
+       Int_t nrecv;
+       if ((nrecv = Read(fd, header.HeaderBaseBegin(), header.HeaderBaseSize())) !=
+           header.HeaderBaseSize()) {
+         if (nrecv == 0) {  // eof
+           if (loop) {
+             ::lseek(fd, 0, SEEK_SET);
+             continue;
+           } else {
+             break;
+           }
+         } else {
+           Error("Run", "error reading base header");
+           Close();
+           delete[] event;
+           return 1;
+         }
+       }
+      }
+      char *data = (char *)header.HeaderBaseBegin();
+      AliRawEventHeaderBase *hdr = AliRawEventHeaderBase::Create(data);
       Int_t nrecv;
-      if ((nrecv = Read(fd, header.HeaderBegin(), header.HeaderSize())) !=
-         header.HeaderSize()) {
+      if ((nrecv = Read(fd, hdr->HeaderBegin(), hdr->HeaderSize())) !=
+         hdr->HeaderSize()) {
        if (nrecv == 0) {  // eof
          if (loop) {
            ::lseek(fd, 0, SEEK_SET);
+           delete hdr;
            continue;
          } else {
+           delete hdr;
            break;
          }
        } else {
          Error("Run", "error reading header");
          Close();
          delete[] event;
+         delete hdr;
          return 1;
        }
       }
-      if (eventSize < header.GetEventSize()) {
+      if (eventSize < hdr->GetEventSize()) {
        delete[] event;
-       eventSize = 2 * header.GetEventSize();
+       eventSize = 2 * hdr->GetEventSize();
        event = new char[eventSize];
       }
-      memcpy(event, header.HeaderBegin(), header.HeaderSize());
-      Int_t size = header.GetEventSize() - header.HeaderSize();
-      if (Read(fd, event + header.HeaderSize(), size) != size) {
+      memcpy(event, hdr->HeaderBaseBegin(), hdr->HeaderBaseSize());
+      memcpy(event+hdr->HeaderBaseSize(), hdr->HeaderBegin(), hdr->HeaderSize());
+      if (hdr->GetExtendedDataSize() != 0)
+       memcpy(event+hdr->HeaderBaseSize()+hdr->HeaderSize(),
+              hdr->GetExtendedData(), hdr->GetExtendedDataSize());
+      Int_t size = hdr->GetEventSize() - hdr->GetHeadSize();
+      if (Read(fd, event + hdr->GetHeadSize(), size) != size) {
        Error("Run", "error reading data");
        Close();
        delete[] event;
+       delete hdr;
        return 1;
       }
+      delete hdr;
     }
 
     Int_t result = ProcessEvent(event, !inputFile);
@@ -639,6 +691,7 @@ Int_t AliMDC::Run(const char* inputFile, Bool_t loop,
   } else {
     // Close input source
     close(fd);
+    delete [] event;
   }
 
   return 0;
@@ -670,34 +723,6 @@ Int_t AliMDC::Read(Int_t fd, void *buffer, Int_t length)
 }
 
 //______________________________________________________________________________
-Int_t AliMDC::ReadHeader(AliRawEventHeader &header, char*& data)
-{
-  // Read header info from DATE data stream. Returns bytes read (i.e.
-  // AliRawEventHeader::HeaderSize()), -1 in case of error and 0 for EOF.
-
-  memcpy(header.HeaderBegin(), data, header.HeaderSize());
-  data += header.HeaderSize();
-
-  // Swap header data if needed
-  if (header.IsSwapped())
-    header.Swap();
-
-  // Is header valid...
-  if (!header.IsValid()) {
-    Error("ReadHeader", "invalid header format");
-    // try recovery... how?
-    return -1;
-  }
-  if (header.GetEventSize() < (UInt_t)header.HeaderSize()) {
-    Error("ReadHeader", "invalid header size");
-    // try recovery... how?
-    return -1;
-  }
-
-  return header.HeaderSize();
-}
-
-//______________________________________________________________________________
 Int_t AliMDC::ReadEquipmentHeader(AliRawEquipmentHeader &header,
                                   Bool_t isSwapped, char*& data)
 {
index eecf241..c931e03 100644 (file)
@@ -26,7 +26,7 @@
 
 // Forward class declarations
 class AliRawEvent;
-class AliRawEventHeader;
+class AliRawEventHeaderBase;
 class AliRawEquipmentHeader;
 class AliRawData;
 class AliRawDB;
@@ -95,6 +95,9 @@ private:
    EFilterMode  fFilterMode;  // high level filter mode
    TObjArray    fFilters;     // filter algorithms
    Bool_t       fStop;        // stop execution (triggered by SIGUSR1)
+   Bool_t       fIsTagDBCreated; // is tag db already created
+   Double_t     fMaxSizeTagDB;// max size of the tag DB
+   const char*  fFileNameTagDB;// tag DB file name
 
    // Filter names
    enum {kNFilters = 1};
@@ -105,7 +108,6 @@ private:
 
    Int_t     Read(const char *name) { return TObject::Read(name); }
    Int_t     Read(Int_t fd, void *buffer, Int_t length);
-   Int_t     ReadHeader(AliRawEventHeader &header, char*& data);
    Int_t     ReadEquipmentHeader(AliRawEquipmentHeader &header,
                                  Bool_t isSwapped, char*& data);
    Int_t     ReadRawData(AliRawData &raw, Int_t size, char*& data);
index 1bf1e61..a2d8ab0 100644 (file)
 #include <TSystem.h>
 #include <TKey.h>
 
-#ifdef ALI_DATE
-#include "event.h"
-#endif
-
 #include "AliESD.h"
 #include "AliRawEvent.h"
-#include "AliRawEventHeader.h"
+#include "AliRawEventHeaderBase.h"
 #include "AliStats.h"
 
 #include "AliRawDB.h"
@@ -61,15 +57,6 @@ AliRawDB::AliRawDB(AliRawEvent *event,
 {
    // Create a new raw DB
 
-   // Consistency check with DATE header file
-#ifdef ALI_DATE
-   if (fEvent->GetHeader()->HeaderSize() != EVENT_HEAD_BASE_SIZE) {
-      Error("AliRawDB", "inconsistency between DATE and AliRawEvent headers");
-      MakeZombie();
-      return;
-   }
-#endif
-
    if (fileName) {
       if (!Create(fileName))
          MakeZombie();
@@ -380,13 +367,13 @@ void AliRawDB::WriteStats(AliStats* stats)
 {
    // Write stats to raw DB, local run DB and global MySQL DB.
 
-   AliRawEventHeader &header = *GetEvent()->GetHeader();
+   AliRawEventHeaderBase &header = *GetEvent()->GetHeader();
 
    // Write stats into RawDB
    TDirectory *ds = gDirectory;
    GetDB()->cd();
    stats->SetEvents(GetEvents());
-   stats->SetLastId(header.GetRunNumber(), header.GetEventInRun());
+   stats->SetLastId(header.Get("RunNb"), header.GetP("Id")[0]);
    stats->SetFileSize(GetBytesWritten());
    stats->SetCompressionFactor(GetCompressionFactor());
    stats->SetEndTime();
index e5fa3cf..47c6f28 100644 (file)
@@ -42,7 +42,9 @@
 
 #include <TObjArray.h>
 
-#include "AliRawEventHeader.h"
+#include "AliLog.h"
+
+#include "AliRawEventHeaderBase.h"
 #include "AliRawEquipment.h"
 
 #include "AliRawEvent.h"
@@ -82,14 +84,28 @@ AliRawEvent& AliRawEvent::operator = (const AliRawEvent& /*rawEvent*/)
 }
 
 //______________________________________________________________________________
-AliRawEventHeader *AliRawEvent::GetHeader()
+AliRawEventHeaderBase *AliRawEvent::GetHeader(char*& data)
 {
-   // Get event header part of AliRawEvent.
+  // Get event header part of AliRawEvent.
+  // First the DATE version is identified and then the
+  // corresponding event header version object is created
+  
+  if (!fEvtHdr) {
+    fEvtHdr = AliRawEventHeaderBase::Create(data);
+  }
+
+  return fEvtHdr;
+}
 
-   if (!fEvtHdr)
-      fEvtHdr = new AliRawEventHeader;
+//______________________________________________________________________________
+AliRawEventHeaderBase *AliRawEvent::GetHeader()
+{
+  if (!fEvtHdr) {
+      AliFatal("Header version not yet initialized!");
+      return 0x0;
+    }
 
-   return fEvtHdr;
+  return fEvtHdr;
 }
 
 //______________________________________________________________________________
index 30d7628..f3cbf27 100644 (file)
@@ -41,7 +41,7 @@
 
 
 // Forward class declarations
-class AliRawEventHeader;
+class AliRawEventHeaderBase;
 class AliRawEquipment;
 
 
@@ -51,7 +51,8 @@ public:
    AliRawEvent();
    virtual ~AliRawEvent();
 
-   AliRawEventHeader     *GetHeader();
+   AliRawEventHeaderBase *GetHeader(char*& data);
+   AliRawEventHeaderBase *GetHeader();
    Int_t                  GetNEquipments() const { return fNEquipments; }
    AliRawEquipment       *NextEquipment();
    AliRawEquipment       *GetEquipment(Int_t index) const;
@@ -63,7 +64,7 @@ public:
 private:
    Int_t                  fNEquipments; // number of valid equipments
    Int_t                  fNSubEvents;  // number of valid sub-events
-   AliRawEventHeader     *fEvtHdr;      // event header object
+   AliRawEventHeaderBase *fEvtHdr;      // event header object
    TObjArray             *fEquipments;  // AliRawEquipment's
    TObjArray             *fSubEvents;   // sub AliRawEvent's
 
diff --git a/RAW/AliRawEventHeader.cxx b/RAW/AliRawEventHeader.cxx
deleted file mode 100644 (file)
index 70da034..0000000
+++ /dev/null
@@ -1,123 +0,0 @@
-// @(#)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.                  *
- **************************************************************************/
-
-//////////////////////////////////////////////////////////////////////////
-//                                                                      //
-// AliRawEventHeader                                                    //
-//                                                                      //
-//////////////////////////////////////////////////////////////////////////
-
-#ifdef ALI_DATE
-#include "event.h"
-#endif
-
-#include "AliRawEventHeader.h"
-
-
-ClassImp(AliRawEventHeader)
-
-
-//______________________________________________________________________________
-Bool_t AliRawEventHeader::DataIsSwapped() const
-{
-   // Returns true if event data is swapped.
-
-#ifdef ALI_DATE
-   if (TEST_SYSTEM_ATTRIBUTE(fTypeAttribute, ATTR_EVENT_SWAPPED))
-      return kTRUE;
-#endif
-   return kFALSE;
-}
-
-//______________________________________________________________________________
-void AliRawEventHeader::Swap()
-{
-   // Swap header data.
-
-   if (IsSwapped()) {
-      fSize         = net2host(fSize);
-      fMagic        = net2host(fMagic);
-      fHeadLen      = net2host(fHeadLen);
-      fVersion      = net2host(fVersion);
-      fType         = net2host(fType);
-      fRunNb        = net2host(fRunNb);
-      for (int i = 0; i < kIdWords; i++)
-         fId[i] = net2host(fId[i]);
-      for (int i = 0; i < kTriggerWords; i++)
-         fTriggerPattern[i] = net2host(fTriggerPattern[i]);
-      for (int i = 0; i < kDetectorWords; i++)
-         fDetectorPattern[i] = net2host(fDetectorPattern[i]);
-      for (int i = 0; i < kAttributeWords; i++)
-         fTypeAttribute[i] = net2host(fTypeAttribute[i]);
-      fLDCId        = net2host(fLDCId);
-      fGDCId        = net2host(fGDCId);
-   }
-}
-
-//______________________________________________________________________________
-UInt_t AliRawEventHeader::GetEventInRun() const
-{
-   // Get event number in run. Correct for fixed target mode which is used
-   // in the Data Challenge Setup.
-
-#ifdef ALI_DATE
-   if (!TEST_SYSTEM_ATTRIBUTE(fTypeAttribute, ATTR_ORBIT_BC)) {
-      return EVENT_ID_GET_NB_IN_RUN(fId);
-   }
-#endif
-   return 0;
-}
-
-//______________________________________________________________________________
-const char *AliRawEventHeader::GetTypeName() const
-{
-   // Get event type as a string.
-
-   switch (GetType()) {
-      case kStartOfRun:
-         return "START_OF_RUN";
-         break;
-      case kEndOfRun:
-         return "END_OF_RUN";
-         break;
-      case kStartOfRunFiles:
-         return "START_OF_RUN_FILES";
-         break;
-      case kEndOfRunFiles:
-         return "END_OF_RUN_FILES";
-         break;
-      case kStartOfBurst:
-         return "START_OF_BURST";
-         break;
-      case kEndOfBurst:
-         return "END_OF_BURST";
-         break;
-      case kPhysicsEvent:
-         return "PHYSICS_EVENT";
-         break;
-      case kCalibrationEvent:
-         return "CALIBRATION_EVENT";
-         break;
-      case kFormatError:
-         return "EVENT_FORMAT_ERROR";
-         break;
-      default:
-         return "*** UNKNOWN EVENT TYPE ***";
-         break;
-   }
-}
diff --git a/RAW/AliRawEventHeader.h b/RAW/AliRawEventHeader.h
deleted file mode 100644 (file)
index 838d5fa..0000000
+++ /dev/null
@@ -1,93 +0,0 @@
-#ifndef ALIRAWEVENTHEADER_H
-#define ALIRAWEVENTHEADER_H
-// @(#)alimdc:$Name$:$Id$
-// Author: Fons Rademakers  26/11/99
-
-/* Copyright(c) 1998-2003, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-//////////////////////////////////////////////////////////////////////////
-//                                                                      //
-// AliRawEventHeader                                                    //
-//                                                                      //
-//////////////////////////////////////////////////////////////////////////
-
-#ifndef ROOT_TObject
-#include <TObject.h>
-#endif
-
-
-class AliRawEventHeader : public TObject {
-
-public:
-   AliRawEventHeader() { fSize = 0; }
-   virtual ~AliRawEventHeader() { }
-
-   void         *HeaderBegin() { return (void *) &fSize; }
-   Int_t         HeaderSize() const { return (Long_t) &fGDCId - (Long_t) &fSize + sizeof(fGDCId); }
-   Bool_t        DataIsSwapped() const;
-   Bool_t        IsSwapped() const { return (fMagic == fgkEventMagicNumberSwapped) ? kTRUE : kFALSE; }
-   Bool_t        IsValid() const { return IsSwapped() ? kTRUE : ((fMagic == fgkEventMagicNumber) ? kTRUE : kFALSE); }
-   void          Swap();
-
-   UInt_t        GetEventSize() const { return fSize; }
-   UInt_t        GetMagic() const { return fMagic; }
-   UInt_t        GetHeaderLength() const { return fHeadLen; }
-   UInt_t        GetVersion() const { return fVersion; }
-   UInt_t        GetType() const { return fType; }
-   const char   *GetTypeName() const;
-   UInt_t        GetRunNumber() const { return fRunNb; }
-   UInt_t        GetEventInRun() const;
-   const UInt_t *GetId() const { return fId; }
-   const UInt_t *GetTriggerPattern() const { return fTriggerPattern; }
-   const UInt_t *GetDetectorPattern() const { return fDetectorPattern; }
-   const UInt_t *GetTypeAttribute() const { return fTypeAttribute; }
-   UInt_t        GetLDCId() const { return fLDCId; }
-   UInt_t        GetGDCId() const { return fGDCId; }
-
-   // The following enumeration can be used once the kEventTypeMask has been
-   // applied to the raw event type
-   enum EAliRawEventType {
-     kStartOfRun =       1,    // START_OF_RUN
-     kEndOfRun =         2,    // END_OF_RUN
-     kStartOfRunFiles =  3,    // START_OF_RUN_FILES
-     kEndOfRunFiles =    4,    // END_OF_RUN_FILES
-     kStartOfBurst =     5,    // START_OF_BURST
-     kEndOfBurst =       6,    // END_OF_BURST
-     kPhysicsEvent =     7,    // PHYSICS_EVENT
-     kCalibrationEvent = 8,    // CALIBRATION_EVENT
-     kFormatError =      9     // EVENT_FORMAT_ERROR
-   };
-
-   // Type sizes
-   enum {
-     kIdWords        = 2,
-     kTriggerWords   = 2,
-     kDetectorWords  = 1,
-     kAttributeWords = 3
-   };
-
-private:
-   UInt_t fSize;          // size of event in bytes
-   UInt_t fMagic;         // magic number used for consistency check
-   UInt_t fHeadLen;       // size of header in bytes
-   UInt_t fVersion;       // unique version identifier
-   UInt_t fType;          // event type
-   UInt_t fRunNb;         // run number
-   UInt_t fId[kIdWords];  // id field
-   UInt_t fTriggerPattern[kTriggerWords];   // trigger pattern
-   UInt_t fDetectorPattern[kDetectorWords]; // detector pattern
-   UInt_t fTypeAttribute[kAttributeWords];  // system (0,1) and user (2) attributes
-   UInt_t fLDCId;         // LDC id
-   UInt_t fGDCId;         // GDC id
-
-   static const Int_t fgkEventTypeMin = kStartOfRun;   // minimal event type
-   static const Int_t fgkEventTypeMax = kFormatError;  // maximal event type
-
-   static const UInt_t fgkEventMagicNumber        = 0xDA1E5AFE; // magic word
-   static const UInt_t fgkEventMagicNumberSwapped = 0xFE5A1EDA; // swapped magic word
-
-   ClassDef(AliRawEventHeader,1)  // Alice raw event header
-};
-
-#endif
diff --git a/RAW/AliRawEventHeaderBase.cxx b/RAW/AliRawEventHeaderBase.cxx
new file mode 100644 (file)
index 0000000..5d8d366
--- /dev/null
@@ -0,0 +1,319 @@
+// Author: Cvetan Cheshkov  10/10/2005
+
+/**************************************************************************
+ * 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.                  *
+ **************************************************************************/
+
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// AliRawEventHeaderBase                                                //
+// This a new versioning scheme for raw data root-ification and reading //
+// For details look at offline weekly meeting 20/10/2005                //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+
+#include <unistd.h>
+
+#include <TClass.h>
+#include <TDataMember.h>
+#include <TMethodCall.h>
+
+#include "AliLog.h"
+#include "AliRawEventHeaderBase.h"
+
+
+ClassImp(AliRawEventHeaderBase)
+
+
+//______________________________________________________________________________
+void *AliRawEventHeaderBase::HeaderBegin()
+{
+  // Returns the pointer to the first data member
+  // beyond the base class data members
+
+  TList *datalist = IsA()->GetListOfDataMembers();
+  TIter next(datalist);                           
+  TDataMember *member = (TDataMember *)next();
+
+  if(!strcmp(member->GetTypeName(),"TClass"))
+    member = (TDataMember *)next();
+
+  return (void *)((char *)this+member->GetOffset());
+}
+
+//______________________________________________________________________________
+Int_t AliRawEventHeaderBase::HeaderSize() const
+{
+  // Returns the size of the data members list
+  // beyond the base class data members
+
+  Int_t size = 0;
+
+  TList *datalist = IsA()->GetListOfDataMembers();
+  TIter next(datalist);                           
+  TDataMember *member;
+  while ((member=(TDataMember *)next()) != 0x0) {
+    if (!strcmp(member->GetTypeName(),"TClass")) continue;
+    UInt_t unitsize = member->GetUnitSize();
+    UInt_t ndim = member->GetArrayDim();
+    if (ndim == 0)
+      size += unitsize;
+    else
+      for(UInt_t i=0;i<ndim;i++) size += member->GetMaxIndex(i)*unitsize;
+  }
+
+  return size;
+}
+
+//______________________________________________________________________________
+void AliRawEventHeaderBase::Swap()
+{
+   // Swap base header data.
+   // Update the fIsSwapped flag which
+   // is then use to copy in an appropriate way
+   // the rest of the header data from the raw data stream
+
+   if (IsSwapped()) {
+      fIsSwapped    = kTRUE;
+      fSize         = net2host(fSize);
+      fMagic        = net2host(fMagic);
+      fHeadSize     = net2host(fHeadSize);
+      fVersion      = net2host(fVersion);
+   }
+}
+
+//______________________________________________________________________________
+const char *AliRawEventHeaderBase::GetTypeName()
+{
+   // Get event type as a string.
+   // Will fail in case data header
+   // does not contain eventType field
+   Int_t eventType = Get("Type");
+
+   switch (eventType) {
+      case kStartOfRun:
+         return "START_OF_RUN";
+         break;
+      case kEndOfRun:
+         return "END_OF_RUN";
+         break;
+      case kStartOfRunFiles:
+         return "START_OF_RUN_FILES";
+         break;
+      case kEndOfRunFiles:
+         return "END_OF_RUN_FILES";
+         break;
+      case kStartOfBurst:
+         return "START_OF_BURST";
+         break;
+      case kEndOfBurst:
+         return "END_OF_BURST";
+         break;
+      case kPhysicsEvent:
+         return "PHYSICS_EVENT";
+         break;
+      case kCalibrationEvent:
+         return "CALIBRATION_EVENT";
+         break;
+      case kFormatError:
+         return "EVENT_FORMAT_ERROR";
+         break;
+      default:
+        return "UNKNOWN EVENT TYPE NUMBER";
+         break;
+   }
+}
+
+//______________________________________________________________________________
+AliRawEventHeaderBase* AliRawEventHeaderBase::Create(char*& data)
+{
+  // Static method to create AliRawEventHeaderVX object
+  // The actual header class version is taken from the
+  // raw data
+
+  // First create AlirawEVentHeaderBase class object
+  AliRawEventHeaderBase header;
+
+  // Copy the first common part of the raw data header
+  memcpy(header.HeaderBaseBegin(), data, header.HeaderBaseSize());
+    // Swap header data if needed
+  if (header.IsSwapped())
+    header.Swap();
+
+  // Is header valid...
+  if (!header.IsValid()) {
+    AliFatalClass("Invalid header format!");
+    // try recovery... how?
+    return 0x0;
+  }
+
+  if (header.GetEventSize() < (UInt_t)header.HeaderBaseSize()) {
+    AliFatalClass("Invalid header base size!");
+    // try recovery... how?
+    return 0x0;
+  }
+
+  // Now check the DATE version and create the corresponding header
+  // class object
+  UInt_t version = header.GetVersion();
+  UInt_t majorversion = (version>>16)&0x0000ffff;
+  UInt_t minorversion = version&0x0000ffff;
+  TString classname;
+  classname.Form("AliRawEventHeaderV%d_%d",majorversion,minorversion);
+    
+  TClass *tcl = TClass::GetClass(classname.Data());
+  if (!tcl) {
+    AliFatalClass(Form("Unknown header version (%s)!",classname.Data()));
+    return 0x0;
+  }
+
+  //  header.Dump(); tcl->Dump();
+
+  AliRawEventHeaderBase *hdr = (AliRawEventHeaderBase *)tcl->New();
+  if (!hdr) {
+    AliFatalClass(Form("Can not create object of class %s",classname.Data()));
+    return 0x0;
+  }
+
+  // Copy the base header data members and initialize other data members
+  memcpy(hdr->HeaderBaseBegin(),header.HeaderBaseBegin(), header.HeaderBaseSize());
+  memset(hdr->HeaderBegin(),0, hdr->HeaderSize());
+  hdr->fIsSwapped = header.fIsSwapped;
+
+  // Consistency check
+  if (hdr->GetEventSize() < ((UInt_t)hdr->HeaderBaseSize() + (UInt_t)hdr->HeaderSize())) {
+    AliFatalClass(Form("Invalid header size (%d < %d +%d)!",
+                      hdr->GetEventSize(),hdr->HeaderBaseSize(),hdr->HeaderSize()));
+    // try recovery... how?
+    return 0x0;
+  }
+
+  // Check for the presence of header extension and its size
+  Int_t extsize = (Int_t)hdr->GetHeadSize() - (hdr->HeaderBaseSize() + hdr->HeaderSize());
+  if (extsize < 0) {
+    AliFatalClass(Form("Invalid header size (%d < %d +%d)!",
+                      hdr->GetHeadSize(),hdr->HeaderBaseSize(),hdr->HeaderSize()));
+    // try recovery... how?
+    return 0x0;
+  }
+  else {
+    if (extsize > 0) {
+      hdr->SetExtendedDataSize(extsize);
+      char *extdata = new char[extsize];
+      memset(extdata,0,extsize);
+      hdr->SetExtendedData(extdata);
+    }
+  }
+
+  return hdr;
+}
+
+//______________________________________________________________________________
+Int_t AliRawEventHeaderBase::ReadHeader(char*& data)
+{
+  // Read header info from DATE data stream.
+  // Returns bytes read
+
+  Long_t start = (Long_t)data;
+  // Swap header data if needed
+  if (DataIsSwapped()) {
+    swab(data,HeaderBaseBegin(), HeaderBaseSize());
+    data += HeaderBaseSize();
+    swab(data, HeaderBegin(), HeaderSize());
+    data += HeaderSize();
+    if(GetExtendedDataSize()>0) {
+      swab(data, GetExtendedData(), GetExtendedDataSize());
+      data += GetExtendedDataSize();
+    }
+  }
+  else {
+    memcpy(HeaderBaseBegin(), data, HeaderBaseSize());
+    data += HeaderBaseSize();
+    memcpy(HeaderBegin(), data, HeaderSize());
+    data += HeaderSize();
+    if(GetExtendedDataSize()>0) {
+      memcpy(GetExtendedData(), data, GetExtendedDataSize());
+      data += GetExtendedDataSize();
+    }
+  }
+
+  return (Int_t)((Long_t)data - start);
+}
+
+//______________________________________________________________________________
+UInt_t AliRawEventHeaderBase::Get(const char *datamember)
+{
+  // The method to get a data member from the header object
+  // Except for the data members of the base class, all the
+  // other header data should be retrieved ONLY by this method
+  // The name of the data member should be supplied without "f"
+  // in front
+
+  char buf[256] = "f";
+  strcat(buf,datamember);
+
+  TDataMember *member = IsA()->GetDataMember(buf);
+  if (!member) {
+    AliFatal(Form("No data member %s is found! Check the raw data version!",buf));
+    return 0;
+  }
+
+  if (member->GetArrayDim() != 0) {
+    AliFatal(Form("Member %s is an array! Use the GetP() method!",buf));
+    return 0;
+  }
+
+  if (strcmp(member->GetTypeName(),"UInt_t") != 0) {
+    AliFatal(Form("Member %s is not of type UInt_t!",buf));
+    return 0;
+  }
+
+  const void *pointer = (char *)this+member->GetOffset();
+
+  return *((UInt_t *)pointer);
+}
+
+//______________________________________________________________________________
+const UInt_t* AliRawEventHeaderBase::GetP(const char *datamember)
+{
+  // The method to get a data member from the header object
+  // Except for the data members of the base class, all the
+  // other header data should be retrieved ONLY by this method
+  // The name of the data member should be supplied without "f"
+  // in front
+
+  char buf[256] = "f";
+  strcat(buf,datamember);
+
+  TDataMember *member = IsA()->GetDataMember(buf);
+  if (!member) {
+    AliFatal(Form("No data member %s is found! Check the raw data version!",buf));
+    return 0;
+  }
+
+  if (member->GetArrayDim() == 0) {
+    AliFatal(Form("Member %s is not an array! Use the Get() method!",buf));
+    return 0;
+  }
+
+  if (strcmp(member->GetTypeName(),"UInt_t") != 0) {
+    AliFatal(Form("Member %s is not of type UInt_t*!",buf));
+    return 0;
+  }
+
+  const void *pointer = (char *)this+member->GetOffset();
+
+  return (const UInt_t*)pointer;
+}
diff --git a/RAW/AliRawEventHeaderBase.h b/RAW/AliRawEventHeaderBase.h
new file mode 100644 (file)
index 0000000..d1237ec
--- /dev/null
@@ -0,0 +1,95 @@
+#ifndef ALIRAWEVENTHEADERBASE_H
+#define ALIRAWEVENTHEADERBASE_H
+
+// Author: Cvetan Cheshkov  10/10/2005
+
+/* Copyright(c) 1998-2005, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// AliRawEventHeaderBase                                                //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+
+//#ifndef ROOT_TObject
+//#include <TObject.h>
+//#endif
+
+class AliRawEventHeaderBase : public TObject {
+
+public:
+   AliRawEventHeaderBase() { fSize=fMagic=fHeadSize=fVersion=fExtendedDataSize=0; fExtendedData = 0x0; fIsSwapped = kFALSE; }
+   virtual ~AliRawEventHeaderBase() { if (fExtendedData) delete [] fExtendedData; }
+
+   void         *HeaderBaseBegin() { return (void *) &fSize; }
+   Int_t         HeaderBaseSize() const { return (Long_t) &fVersion - (Long_t) &fSize + sizeof(fVersion); }
+   void         *HeaderBegin();
+   Int_t         HeaderSize() const;
+   Bool_t        DataIsSwapped() const { return fIsSwapped; }
+   Bool_t        IsSwapped() const { return (fMagic == fgkEventMagicNumberSwapped) ? kTRUE : kFALSE; }
+   Bool_t        IsValid() const { return IsSwapped() ? kTRUE : ((fMagic == fgkEventMagicNumber) ? kTRUE : kFALSE); }
+   void          Swap();
+
+   UInt_t        GetEventSize() const { return fSize; }
+   UInt_t        GetMagic() const { return fMagic; }
+   UInt_t        GetHeadSize() const { return fHeadSize; }
+   UInt_t        GetVersion() const { return fVersion; }
+   UInt_t        GetMajorVersion() const { return ((fVersion>>16)&0x0000ffff); }
+   UInt_t        GetMinorVersion() const { return (fVersion&0x0000ffff); }
+
+   UInt_t        GetExtendedDataSize() const { return fExtendedDataSize; }
+   char*         GetExtendedData() const { return fExtendedData; }
+   void          SetExtendedDataSize(Int_t size) { fExtendedDataSize = size; }
+   void          SetExtendedData(char *data) { fExtendedData = data; }
+
+   const char *  GetTypeName();
+   static AliRawEventHeaderBase* Create(char*& data);
+   Int_t         ReadHeader(char*& data);
+   UInt_t        Get(const char *datamember);
+   const UInt_t* GetP(const char *datamember);
+
+   // The following enumeration can be used once the kEventTypeMask has been
+   // applied to the raw event type
+   enum EAliRawEventType {
+     kStartOfRun =       1,    // START_OF_RUN
+     kEndOfRun =         2,    // END_OF_RUN
+     kStartOfRunFiles =  3,    // START_OF_RUN_FILES
+     kEndOfRunFiles =    4,    // END_OF_RUN_FILES
+     kStartOfBurst =     5,    // START_OF_BURST
+     kEndOfBurst =       6,    // END_OF_BURST
+     kPhysicsEvent =     7,    // PHYSICS_EVENT
+     kCalibrationEvent = 8,    // CALIBRATION_EVENT
+     kFormatError =      9     // EVENT_FORMAT_ERROR
+   };
+
+private:
+   UInt_t fSize;          // size of event in bytes
+   UInt_t fMagic;         // magic number used for consistency check
+   UInt_t fHeadSize;      // size of header in bytes
+   UInt_t fVersion;       // unique version identifier
+
+   UInt_t fExtendedDataSize; // size of header extension data
+   char  *fExtendedData;  //[fExtendedDataSize] pointer to header extension data 
+
+   Bool_t fIsSwapped;     // is data swapped
+
+   static const UInt_t fgkEventMagicNumber        = 0xDA1E5AFE; // magic word
+   static const UInt_t fgkEventMagicNumberSwapped = 0xFE5A1EDA; // swapped magic word
+
+   ClassDef(AliRawEventHeaderBase,1)  // Alice raw event header base class
+};
+
+#define START_EVENT_HEADER(AA,BB) \
+class AliRawEventHeaderV##AA##_##BB##:public AliRawEventHeaderBase { \
+public: \
+   AliRawEventHeaderV##AA##_##BB##():AliRawEventHeaderBase() {}; \
+   virtual ~AliRawEventHeaderV##AA##_##BB##() {}; \
+private:
+
+#define END_EVENT_HEADER(AA,BB) \
+ClassDef(AliRawEventHeaderV##AA##_##BB##,1) \
+}; \
+ClassImp(AliRawEventHeaderV##AA##_##BB##)
+
+#endif
diff --git a/RAW/AliRawEventHeaderVersions.h b/RAW/AliRawEventHeaderVersions.h
new file mode 100644 (file)
index 0000000..3a84d01
--- /dev/null
@@ -0,0 +1,74 @@
+#ifndef ALIRAWEVENTHEADERVERSIONS_H
+#define ALIRAWEVENTHEADERVERSIONS_H
+
+#include "AliRawEventHeaderBase.h"
+
+START_EVENT_HEADER(3,1)
+
+   UInt_t fType;          // event type
+   UInt_t fRunNb;     // run number
+   UInt_t fId[2];  // id field
+   UInt_t fTriggerPattern[2];   // trigger pattern
+   UInt_t fDetectorPattern[1]; // detector pattern
+   UInt_t fTypeAttribute[3];  // system (0,1) and user (2) attributes
+   UInt_t fLdcId;         // LDC id
+   UInt_t fGdcId;         // GDC id
+
+END_EVENT_HEADER(3,1)
+
+START_EVENT_HEADER(3,2)
+
+   UInt_t fType;          // event type
+   UInt_t fRunNb;     // run number
+   UInt_t fId[2];  // id field
+   UInt_t fTriggerPattern[2];   // trigger pattern
+   UInt_t fDetectorPattern[1]; // detector pattern
+   UInt_t fTypeAttribute[3];  // system (0,1) and user (2) attributes
+   UInt_t fLdcId;         // LDC id
+   UInt_t fGdcId;         // GDC id
+
+END_EVENT_HEADER(3,2)
+
+START_EVENT_HEADER(3,3)
+
+   UInt_t fType;          // event type
+   UInt_t fRunNb;     // run number
+   UInt_t fId[2];  // id field
+   UInt_t fTriggerPattern[2];   // trigger pattern
+   UInt_t fDetectorPattern[1]; // detector pattern
+   UInt_t fTypeAttribute[3];  // system (0,1) and user (2) attributes
+   UInt_t fLdcId;         // LDC id
+   UInt_t fGdcId;         // GDC id
+
+END_EVENT_HEADER(3,3)
+
+START_EVENT_HEADER(3,4)
+
+   UInt_t fType;          // event type
+   UInt_t fRunNb;     // run number
+   UInt_t fId[2];  // id field
+   UInt_t fTriggerPattern[2];   // trigger pattern
+   UInt_t fDetectorPattern[1]; // detector pattern
+   UInt_t fTypeAttribute[3];  // system (0,1) and user (2) attributes
+   UInt_t fLdcId;         // LDC id
+   UInt_t fGdcId;         // GDC id
+   UInt_t fTimestamp;     // event timestamp
+
+END_EVENT_HEADER(3,4)
+
+START_EVENT_HEADER(3,5)
+
+   UInt_t fType;          // event type
+   UInt_t fRunNb;     // run number
+   UInt_t fId[2];  // id field
+   UInt_t fTriggerPattern[2];   // trigger pattern
+   UInt_t fDetectorPattern[1]; // detector pattern
+   UInt_t fTypeAttribute[3];  // system (0,1) and user (2) attributes
+   UInt_t fLdcId;         // LDC id
+   UInt_t fGdcId;         // GDC id
+   UInt_t fTimestamp;     // event timestamp
+
+END_EVENT_HEADER(3,5)
+
+
+#endif
index 84c10ce..5d9dc16 100644 (file)
@@ -32,7 +32,7 @@
 #include <TTree.h>
 #include "AliRawReaderRoot.h"
 #include "AliRawEvent.h"
-#include "AliRawEventHeader.h"
+#include "AliRawEventHeaderBase.h"
 #include "AliRawEquipment.h"
 #include "AliRawEquipmentHeader.h"
 #include "AliRawData.h"
@@ -192,7 +192,7 @@ UInt_t AliRawReaderRoot::GetType() const
 // get the type from the event header
 
   if (!fEvent) return 0;
-  return fEvent->GetHeader()->GetType();
+  return fEvent->GetHeader()->Get("Type");
 }
 
 UInt_t AliRawReaderRoot::GetRunNumber() const
@@ -200,7 +200,7 @@ UInt_t AliRawReaderRoot::GetRunNumber() const
 // get the run number from the event header
 
   if (!fEvent) return 0;
-  return fEvent->GetHeader()->GetRunNumber();
+  return fEvent->GetHeader()->Get("RunNb");
 }
 
 const UInt_t* AliRawReaderRoot::GetEventId() const
@@ -208,7 +208,7 @@ const UInt_t* AliRawReaderRoot::GetEventId() const
 // get the event id from the event header
 
   if (!fEvent) return NULL;
-  return fEvent->GetHeader()->GetId();
+  return fEvent->GetHeader()->GetP("Id");
 }
 
 const UInt_t* AliRawReaderRoot::GetTriggerPattern() const
@@ -216,7 +216,7 @@ const UInt_t* AliRawReaderRoot::GetTriggerPattern() const
 // get the trigger pattern from the event header
 
   if (!fEvent) return NULL;
-  return fEvent->GetHeader()->GetTriggerPattern();
+  return fEvent->GetHeader()->GetP("TriggerPattern");
 }
 
 const UInt_t* AliRawReaderRoot::GetDetectorPattern() const
@@ -224,7 +224,7 @@ const UInt_t* AliRawReaderRoot::GetDetectorPattern() const
 // get the detector pattern from the event header
 
   if (!fEvent) return NULL;
-  return fEvent->GetHeader()->GetDetectorPattern();
+  return fEvent->GetHeader()->GetP("DetectorPattern");
 }
 
 const UInt_t* AliRawReaderRoot::GetAttributes() const
@@ -232,7 +232,7 @@ const UInt_t* AliRawReaderRoot::GetAttributes() const
 // get the type attributes from the event header
 
   if (!fEvent) return NULL;
-  return fEvent->GetHeader()->GetTypeAttribute();
+  return fEvent->GetHeader()->GetP("TypeAttribute");
 }
 
 const UInt_t* AliRawReaderRoot::GetSubEventAttributes() const
@@ -240,7 +240,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,7 +248,7 @@ 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
@@ -256,7 +256,7 @@ UInt_t AliRawReaderRoot::GetGDCId() const
 // get the GDC Id from the event header
 
   if (!fEvent) return 0;
-  return fEvent->GetHeader()->GetGDCId();
+  return fEvent->GetHeader()->Get("GdcId");
 }
 
 
index 453643f..6765833 100644 (file)
@@ -25,9 +25,6 @@
 #include <TH1.h>
 #include <TFile.h>
 
-#include "AliRawEvent.h"
-#include "AliRawEventHeader.h"
-
 #include "AliStats.h"
 
 
index 1fa4218..298bcf7 100644 (file)
@@ -29,7 +29,7 @@
 #include "AliESD.h"
 
 #include "AliRawDB.h"
-#include "AliRawEventHeader.h"
+#include "AliRawEventHeaderBase.h"
 #include "AliTagDB.h"
 
 
@@ -37,7 +37,7 @@ ClassImp(AliTagDB)
 
 
 //______________________________________________________________________________
-AliTagDB::AliTagDB(AliRawEventHeader *header, const char* fileName) :
+AliTagDB::AliTagDB(AliRawEventHeaderBase *header, const char* fileName) :
   fTagDB(NULL),
   fTree(NULL),
   fHeader(header),
@@ -97,7 +97,8 @@ Bool_t AliTagDB::Create(const char* fileName)
 
    Int_t bufsize = 32000;
    Int_t split   = 1;
-   fTree->Branch("header", "AliRawEventHeader", &fHeader, bufsize, split);
+   const char *headername = fHeader->GetName();
+   fTree->Branch("header", headername, &fHeader, bufsize, split);
 
    return kTRUE;
 }
index adf8321..8490d6f 100644 (file)
 
 
 // Forward class declarations
-class AliRawEventHeader;
+class AliRawEventHeaderBase;
 
 
 class AliTagDB : public TObject {
 
 public:
-   AliTagDB(AliRawEventHeader *header, const char* fileName = NULL);
+   AliTagDB(AliRawEventHeaderBase *header, const char* fileName = NULL);
    virtual ~AliTagDB() { Close(); }
 
    Bool_t          Create(const char* fileName = NULL);
@@ -54,14 +54,14 @@ public:
    Double_t           GetBytesWritten() const { return fTagDB->GetBytesWritten(); }
    TFile             *GetDB() const { return fTagDB; }
    const char        *GetDBName() const { return fTagDB->GetName(); }
-   AliRawEventHeader *GetHeader() const { return fHeader; }
+   AliRawEventHeaderBase *GetHeader() const { return fHeader; }
    Int_t              GetEvents() const { return (Int_t) fTree->GetEntries(); }
    Float_t            GetCompressionFactor() const;
 
 protected:
    TFile             *fTagDB;     // DB to store header information only (tag)
    TTree             *fTree;      // tree use to store header
-   AliRawEventHeader *fHeader;    // header via which data is stored
+   AliRawEventHeaderBase *fHeader;    // header via which data is stored
    Double_t           fMaxSize;   // maximum size in bytes of tag DB
    TString            fFS;        // tag DB file system location
    Bool_t             fDeleteFiles; // flag for deletion of files
index 4d58498..9843833 100644 (file)
@@ -29,7 +29,7 @@ ClassImp(AliTagNullDB)
 
 
 //______________________________________________________________________________
-AliTagNullDB::AliTagNullDB(AliRawEventHeader *header) :
+AliTagNullDB::AliTagNullDB(AliRawEventHeaderBase *header) :
    AliTagDB(header, "/dev/null")
 {
    // Create tag db writing to /dev/null.
index 53e609b..06f407a 100644 (file)
@@ -18,7 +18,7 @@
 class AliTagNullDB : public AliTagDB {
 
 public:
-   AliTagNullDB(AliRawEventHeader *header);
+   AliTagNullDB(AliRawEventHeaderBase *header);
    ~AliTagNullDB() { Close(); }
 
    void Close();
index 3cefda9..2c55f55 100644 (file)
@@ -5,7 +5,8 @@
 #pragma link off all functions;
 
 #pragma link C++ class AliRawEvent;
-#pragma link C++ class AliRawEventHeader;
+#pragma link C++ class AliRawEventHeaderBase;
+#pragma link C++ defined_in RAW/AliRawEventHeaderVersions.h;
 #pragma link C++ class AliRawEquipmentHeader;
 #pragma link C++ class AliRawEquipment;
 #pragma link C++ class AliRawData;
index 49208a9..77dd2fe 100644 (file)
@@ -7,7 +7,7 @@ PACKCXXFLAGS := ${HLTCXXFLAGS}
 PACKCFLAGS   := ${HLTCLFAGS}
 PACKDCXXFLAGS:= ${HLTDCXXFLAGS}
 
-SRCS:=  AliRawEventHeader.cxx AliRawEquipmentHeader.cxx \
+SRCS:=  AliRawEventHeaderBase.cxx AliRawEquipmentHeader.cxx \
        AliRawData.cxx AliRawEquipment.cxx AliRawEvent.cxx \
        AliStats.cxx AliFilter.cxx \
        AliRawReader.cxx AliRawReaderFile.cxx AliRawReaderRoot.cxx \
@@ -20,6 +20,8 @@ SRCS:=  AliRawEventHeader.cxx AliRawEquipmentHeader.cxx \
 
 HDRS:= $(SRCS:.cxx=.h)
 
+HDRS += AliRawEventHeaderVersions.h
+
 EHDRS:=$(shell root-config --incdir)/TH1F.h
 
 EINCLUDE+= TPC ITS RAW HLT/src HLT/hough HLT/comp HLT/ITS