ALIROOT-5433 Transition to CDHv3 in HLT
authortbreitne <timo.gunther.breitner@cern.ch>
Tue, 20 May 2014 11:50:23 +0000 (13:50 +0200)
committertbreitne <timo.gunther.breitner@cern.ch>
Tue, 20 May 2014 13:23:41 +0000 (15:23 +0200)
53 files changed:
HLT/BASE/AliHLTCDHWrapper.h [new file with mode: 0644]
HLT/BASE/AliHLTCTPData.cxx
HLT/BASE/AliHLTCTPData.h
HLT/BASE/AliHLTComponent.cxx
HLT/BASE/AliHLTComponent.h
HLT/BASE/AliHLTDataTypes.h
HLT/BASE/AliHLTMisc.cxx
HLT/BASE/AliHLTMisc.h
HLT/BASE/AliHLTSystem.cxx
HLT/BASE/AliHLTSystem.h
HLT/BASE/AliHLTTask.cxx
HLT/BASE/AliHLTTask.h
HLT/BASE/util/AliHLTRawReaderPublisherComponent.cxx
HLT/BASE/util/AliHLTReadoutListDumpComponent.cxx
HLT/EMCAL/AliHLTEMCALDigitMakerComponent.cxx
HLT/MUON/OfflineInterface/AliHLTMUONDigitPublisherComponent.cxx
HLT/MUON/OnlineAnalysis/AliHLTMUONHitReconstructor.cxx
HLT/MUON/OnlineAnalysis/AliHLTMUONTriggerReconstructor.cxx
HLT/MUON/OnlineAnalysis/AliHLTMUONTriggerReconstructorComponent.cxx
HLT/MUON/utils/AliHLTMUONDataCheckerComponent.cxx
HLT/MUON/utils/AliHLTMUONRawDataHistoComponent.cxx
HLT/RCU/AliHLTAltroGenerator.cxx
HLT/RCU/AliHLTAltroGenerator.h
HLT/RCU/AliHLTAltroTimebinAverageComponent.cxx
HLT/TPCLib/AliHLTTPCHWCFData.cxx
HLT/TPCLib/AliHLTTPCHWCFDataReverterComponent.cxx
HLT/TPCLib/AliHLTTPCHWCFSpacePointContainer.cxx
HLT/TPCLib/AliHLTTPCHWClusterDecoderComponent.cxx
HLT/TPCLib/AliHLTTPCHWClusterTransformComponent.cxx
HLT/TPCLib/AliHLTTPCRawSpacePointContainer.cxx
HLT/TPCLib/HWCFemulator/AliHLTTPCHWCFConsistencyControlComponent.cxx
HLT/TPCLib/HWCFemulator/AliHLTTPCHWCFEmulatorComponent.cxx
HLT/TPCLib/HWCFemulator/AliHLTTPCHWCFSupport.cxx
HLT/TPCLib/calibration/AliHLTTPCCalibCEComponent.cxx
HLT/TPCLib/calibration/AliHLTTPCCalibPedestalComponent.cxx
HLT/TPCLib/calibration/AliHLTTPCCalibPulserComponent.cxx
HLT/TPCLib/comp/AliHLTTPCDataCompressionComponent.cxx
HLT/TPCLib/comp/AliHLTTPCDataCompressionIDMap.cxx
HLT/TPCLib/comp/AliHLTTPCDataCompressionMonitorComponent.cxx
HLT/TRD/AliHLTTRDEsdWriterComponent.cxx
HLT/global/AliHLTGlobalEsdConverterComponent.cxx
HLT/rec/AliHLTMiscImplementation.cxx
HLT/rec/AliHLTMiscImplementation.h
HLT/rec/AliHLTOUTDigitReader.cxx
HLT/rec/AliHLTOUTDigitReader.h
HLT/rec/AliHLTOUTHomerCollection.cxx
HLT/rec/AliHLTOUTHomerCollection.h
HLT/rec/AliHLTOUTRawReader.cxx
HLT/rec/AliHLTOUTRawReader.h
HLT/rec/AliRawReaderHLT.cxx
HLT/sim/AliHLTOUTComponent.cxx
HLT/trigger/AliHLTGlobalTriggerComponent.cxx
HLT/trigger/AliHLTGlobalTriggerComponent.h

diff --git a/HLT/BASE/AliHLTCDHWrapper.h b/HLT/BASE/AliHLTCDHWrapper.h
new file mode 100644 (file)
index 0000000..f414735
--- /dev/null
@@ -0,0 +1,125 @@
+#ifndef ALIHLTCDHWRAPPER_H
+#define ALIHLTCDHWRAPPER_H
+
+#include <assert.h>
+#include "AliRawDataHeader.h"
+#include "AliRawDataHeaderV3.h"
+
+#define CHECK_AND_CALL(func, args...)                                  \
+  ( GetVersion() == 2 ?                                                        \
+    reinterpret_cast<const AliRawDataHeader*>(fCDH)->func(args) :      \
+    reinterpret_cast<const AliRawDataHeaderV3*>(fCDH)->func(args) )
+
+
+class AliHLTCDHWrapper {
+ public:
+  AliHLTCDHWrapper() : fCDH(NULL) {}
+  AliHLTCDHWrapper(const AliHLTCDHWrapper& other) : fCDH(other.fCDH) { CheckVersion(); }
+  AliHLTCDHWrapper(const void* cdh) : fCDH(cdh) { CheckVersion(); }
+
+  ~AliHLTCDHWrapper() {}
+
+  inline AliHLTCDHWrapper& operator=(const AliHLTCDHWrapper& other) { 
+    fCDH = other.fCDH;
+    CheckVersion(); 
+    return *this;
+  }
+
+  inline AliHLTCDHWrapper& operator=(const void*& cdh) { 
+    fCDH = cdh;
+    CheckVersion(); 
+    return *this;
+  }
+
+  inline void CheckVersion() {
+    if(fCDH)
+      assert(GetVersion() == 2 || GetVersion() == 3);
+  }
+  
+  inline UChar_t GetVersion() const { 
+    return (reinterpret_cast<const AliRawDataHeader*>(fCDH))->GetVersion();
+  }
+
+  inline UInt_t GetHeaderSize() {
+    return (GetVersion() == 2 ? 
+           sizeof(AliRawDataHeader) : sizeof(AliRawDataHeaderV3) );
+  }
+
+  inline const void* GetHeader() const {
+    return fCDH;
+  }
+
+  inline UInt_t GetDataSize() const {
+    //first word, independent of Version
+    return *((UInt_t*)fCDH);
+  }
+
+  inline UShort_t GetEventID1() const {
+    return CHECK_AND_CALL(GetEventID1);
+  }
+
+  inline UInt_t GetEventID2() const {
+    return CHECK_AND_CALL(GetEventID2);
+  }
+
+  inline UChar_t GetL1TriggerMessage() const {
+    return CHECK_AND_CALL(GetL1TriggerMessage);
+  }
+
+  inline UChar_t GetAttributes() const {
+    return CHECK_AND_CALL(GetAttributes);
+  }
+
+  inline Bool_t TestAttribute(Int_t index) const {
+    return CHECK_AND_CALL(TestAttribute, index);
+  }
+
+  /*
+  inline void SetAttribute(Int_t index) {
+    CHECK_AND_CALL(SetAttribute, index);
+  }
+  */
+
+  /*
+  inline void ResetAttribute(Int_t index) {
+    CHECK_AND_CALL(ResetAttribute, index);
+  }
+  */
+
+  inline UInt_t GetSubDetectors() const {
+    return CHECK_AND_CALL(GetSubDetectors);
+  }
+
+  inline UInt_t GetStatus() const {
+    return CHECK_AND_CALL(GetStatus);
+  }
+
+  inline UInt_t GetMiniEventID() const {
+    return CHECK_AND_CALL(GetMiniEventID);
+  }
+
+  inline ULong64_t GetTriggerClasses() const {
+    return CHECK_AND_CALL(GetTriggerClasses);
+  }
+
+  inline ULong64_t GetTriggerClassesNext50() const {
+    return CHECK_AND_CALL(GetTriggerClassesNext50);
+  }
+
+  inline ULong64_t GetROI() const {
+    return CHECK_AND_CALL(GetROI);
+  }
+
+  /*
+  inline void SetTriggerClass(ULong64_t mask) {
+    CHECK_AND_CALL(SetTriggerClass, mask);
+  }
+  */
+
+ private:
+  const void* fCDH;
+
+};
+
+
+#endif
index a1bad7a..c14026e 100644 (file)
@@ -27,7 +27,9 @@
 #include "TObjString.h"
 #include "TFormula.h"
 #include "AliHLTComponent.h"
-#include "AliRawDataHeader.h"
+#include "AliHLTCDHWrapper.h"
+#include <limits>
+#include <sstream>
 
 /** ROOT macro for the implementation of ROOT specific class methods */
 ClassImp(AliHLTCTPData)
@@ -191,7 +193,7 @@ int AliHLTCTPData::InitCTPTriggerClasses(const char* ctpString)
          if (index<gkNCTPTriggerClasses) {
            AliHLTReadoutList* pCTPClass=dynamic_cast<AliHLTReadoutList*>(fClassIds.At(index));
            if (pCTPClass) {
-             fMask|=(AliHLTUInt64_t)0x1 << index;
+             fMask.set(index);
              pCTPClass->SetTitle("CTP Class");
              pCTPClass->SetName((((TObjString*)entryParams->At(kName))->GetString()).Data());
              TObjArray* detectors=(((TObjString*)entryParams->At(kDetectors))->GetString()).Tokenize("-");
@@ -209,7 +211,7 @@ int AliHLTCTPData::InitCTPTriggerClasses(const char* ctpString)
            } else {
            }
          } else {
-           // the trigger bitfield is fixed to 50 bits (gkNCTPTriggerClasses)
+           // the trigger bitfield is fixed to 100 bits (gkNCTPTriggerClasses)
            HLTError("invalid trigger class entry %s, index width of trigger bitfield exceeded (%d)", entry.Data(), gkNCTPTriggerClasses);
          }
        } else {
@@ -227,39 +229,43 @@ int AliHLTCTPData::InitCTPTriggerClasses(const char* ctpString)
   return 0;
 }
 
-AliHLTUInt64_t AliHLTCTPData::ActiveTriggers(const AliHLTComponentTriggerData& trigData)
+AliHLTTriggerMask_t AliHLTCTPData::ActiveTriggers(const AliHLTComponentTriggerData& trigData)
 {
   // extract active triggers from the trigger data
+  AliHLTCDHWrapper cdh;
+  if (AliHLTComponent::ExtractTriggerData(trigData, NULL, NULL, &cdh, NULL) != 0) return 0x0;
+  if ((cdh.GetL1TriggerMessage() & 0x1) == 0x1) return 0x0;  // invalid for software triggers.
 
-  const AliRawDataHeader* cdh = NULL;
-  if (AliHLTComponent::ExtractTriggerData(trigData, NULL, NULL, &cdh, NULL) != 0) return (AliHLTUInt64_t)0;
-  if ((cdh->GetL1TriggerMessage() & 0x1) == 0x1) return 0x0;  // invalid for software triggers.
-  // trigger mask is 50 bit wide and is stored in word 5 and 6 of the CDH
-  AliHLTUInt64_t triggerMask = cdh->GetTriggerClasses();
-  return triggerMask;
+  AliHLTTriggerMask_t triggerLow(cdh.GetTriggerClasses()); //low bits
+  AliHLTTriggerMask_t triggerHigh(cdh.GetTriggerClassesNext50()); // high bits
+
+  return triggerLow | (triggerHigh << 50);
 }
 
 bool AliHLTCTPData::EvaluateCTPTriggerClass(const char* expression, const AliHLTComponentTriggerData& trigData) const
 {
   // see header file for function documentation
   
-  const AliRawDataHeader* cdh = NULL;
+  AliHLTCDHWrapper cdh;
   if (AliHLTComponent::ExtractTriggerData(trigData, NULL, NULL, &cdh, NULL, true) != 0) return false;
-  if ((cdh->GetL1TriggerMessage() & 0x1) == 0x1) return false;  // invalid for software triggers.
-  // trigger mask is 50 bit wide and is stored in word 5 and 6 of the CDH
-  AliHLTUInt64_t triggerMask = cdh->GetTriggerClasses();
+  if ((cdh.GetL1TriggerMessage() & 0x1) == 0x1) return false;  // invalid for software triggers.
+
+  AliHLTTriggerMask_t triggerMask(cdh.GetTriggerClasses());
+  AliHLTTriggerMask_t triggerHigh(cdh.GetTriggerClassesNext50());
+  triggerMask |= (triggerHigh << 50);
 
   if (fMask!=0 && (triggerMask & fMask)==0) {
     AliHLTEventTriggerData* evtData=reinterpret_cast<AliHLTEventTriggerData*>(trigData.fData);
-    HLTWarning("invalid trigger mask 0x%llx, unknown CTP trigger, initialized 0x%llx", triggerMask, fMask);
-    for (int i=0; i<8; i++) HLTWarning("\t CDH[%d]=0x%lx", i, evtData->fCommonHeader[i]);
+    HLTWarning("invalid trigger mask %s, unknown CTP trigger, initialized %s", 
+              TriggerMaskToString(triggerMask).c_str(), TriggerMaskToString(fMask).c_str() );
+    for (int i=0; i<gkAliHLTCommonHeaderCount; i++) HLTWarning("\t CDH[%d]=0x%lx", i, evtData->fCommonHeader[i]);
     return false;
   }
 
   return EvaluateCTPTriggerClass(expression, triggerMask);
 }
 
-bool AliHLTCTPData::EvaluateCTPTriggerClass(const char* expression, AliHLTUInt64_t triggerMask) const
+bool AliHLTCTPData::EvaluateCTPTriggerClass(const char* expression, AliHLTTriggerMask_t triggerMask) const
 {
   // see header file for function documentation
 
@@ -286,7 +292,7 @@ bool AliHLTCTPData::EvaluateCTPTriggerClass(const char* expression, AliHLTUInt64
        TString replace; replace.Form("[%d]", (int)par.size());
        //HLTDebug("replacing %s with %s in \"%s\"", className.Data(), replace.Data(), condition.Data());
        condition.ReplaceAll(className, replace);
-       if (triggerMask&((AliHLTUInt64_t)0x1<<(*pMap)[index])) par.push_back(1.0);
+       if ( triggerMask.test((*pMap)[index]) ) par.push_back(1.0);
        else par.push_back(0.0);
       }
     }
@@ -320,7 +326,7 @@ int AliHLTCTPData::CheckTrigger(const char* name) const
   // check status of a trigger class
   int index=Index(name);
   if (index<0) return index;
-  return (fTriggers&(0x1<<index))>0?1:0;
+  return ( fTriggers.test(index) ? 1 : 0 );
 }
 
 void AliHLTCTPData::Increment(const char* classIds)
@@ -337,12 +343,12 @@ void AliHLTCTPData::Increment(const char* classIds)
   }
 }
 
-void AliHLTCTPData::Increment(AliHLTUInt64_t triggerPattern)
+void AliHLTCTPData::Increment(AliHLTTriggerMask_t triggerPattern)
 {
   // see header file for function documentation
-  AliHLTUInt64_t pattern=triggerPattern&fMask;
+  AliHLTTriggerMask_t pattern=triggerPattern&fMask;
   for (int i=0; i<fCounters.GetSize(); i++) {
-    if ((pattern&((AliHLTUInt64_t)0x1<<i))==0) continue;
+    if (!pattern.test(i)) continue;
     fCounters[i]++;    
   }
 }
@@ -351,7 +357,7 @@ void AliHLTCTPData::Increment(int classIdx)
 {
   // see header file for function documentation
   if (classIdx<fCounters.GetSize() &&
-      (fMask&((AliHLTUInt64_t)0x1<<classIdx))) {
+      fMask.test(classIdx)) {
     fCounters[classIdx]++;    
   }
   
@@ -360,17 +366,21 @@ void AliHLTCTPData::Increment(int classIdx)
 int AliHLTCTPData::Increment(AliHLTComponentTriggerData& trigData)
 {
   // see header file for function documentation
-  const AliRawDataHeader* cdh = NULL;
+  AliHLTCDHWrapper cdh;
   int result = AliHLTComponent::ExtractTriggerData(trigData, NULL, NULL, &cdh, NULL, true);
   if (result != 0) return result;
-  if ((cdh->GetL1TriggerMessage() & 0x1) == 0x1) return 0;  // invalid for software triggers.
-  // trigger mask is 50 bit wide and is stored in word 5 and 6 of the CDH
-  AliHLTUInt64_t triggerMask = cdh->GetTriggerClasses();
+  if ((cdh.GetL1TriggerMessage() & 0x1) == 0x1) return 0;  // invalid for software triggers.
 
-  if (fMask!=0 && (triggerMask & fMask)==0) {
+  AliHLTTriggerMask_t triggerMask(cdh.GetTriggerClasses());
+  AliHLTTriggerMask_t triggerHigh(cdh.GetTriggerClassesNext50());
+  triggerMask |= (triggerHigh << 50);
+
+  if (fMask.any() && (triggerMask & fMask).none()) {
     AliHLTEventTriggerData* evtData=reinterpret_cast<AliHLTEventTriggerData*>(trigData.fData);
-    HLTWarning("invalid trigger mask 0x%llx, unknown CTP trigger, initialized 0x%llx", triggerMask, fMask);
-    for (int i=0; i<8; i++) HLTWarning("\t CDH[%d]=0x%lx", i, evtData->fCommonHeader[i]);
+    HLTWarning("invalid trigger mask %s, unknown CTP trigger, initialized %s", 
+              TriggerMaskToString(triggerMask).c_str(), TriggerMaskToString(fMask).c_str());
+    for (int i=0; i<gkAliHLTCommonHeaderCount; i++) 
+      HLTWarning("\t CDH[%d]=0x%lx", i, evtData->fCommonHeader[i]);
   }
   Increment(triggerMask);
   return 0;
@@ -426,31 +436,35 @@ AliHLTReadoutList AliHLTCTPData::ReadoutList(const AliHLTComponentTriggerData& t
 {
   // see header file for function documentation
 
-  const AliRawDataHeader* cdh = NULL;
+  AliHLTCDHWrapper cdh;
   if (AliHLTComponent::ExtractTriggerData(trigData, NULL, NULL, &cdh, NULL, true) != 0) return AliHLTReadoutList();
   // Check if we are dealing with a software trigger. If so then we need to return
   // a readout list with everything set because the CTP trigger bits are invalid.
   // Thus we assume that everything should be read out.
-  if ((cdh->GetL1TriggerMessage() & 0x1) == 0x1) return ~ AliHLTReadoutList();
-  // trigger mask is 50 bit wide and is stored in word 5 and 6 of the CDH
-  AliHLTUInt64_t triggerMask = cdh->GetTriggerClasses();
+  if ((cdh.GetL1TriggerMessage() & 0x1) == 0x1) return ~ AliHLTReadoutList();
 
-  if (fMask!=0 && (triggerMask & fMask)==0) {
+  AliHLTTriggerMask_t triggerMask(cdh.GetTriggerClasses());
+  AliHLTTriggerMask_t triggerHigh(cdh.GetTriggerClassesNext50());
+  triggerMask |= (triggerHigh << 50);
+
+  if (fMask.any() && (triggerMask & fMask).none()) {
     AliHLTEventTriggerData* evtData=reinterpret_cast<AliHLTEventTriggerData*>(trigData.fData);
-    HLTWarning("invalid trigger mask 0x%llx, unknown CTP trigger, initialized 0x%llx", triggerMask, fMask);
-    for (int i=0; i<8; i++) HLTWarning("\t CDH[%d]=0x%lx", i, evtData->fCommonHeader[i]);
+    HLTWarning("invalid trigger mask %s, unknown CTP trigger, initialized %s",
+               TriggerMaskToString(triggerMask).c_str(), TriggerMaskToString(fMask).c_str());
+    for (int i=0; i<gkAliHLTCommonHeaderCount; i++)
+      HLTWarning("\t CDH[%d]=0x%lx", i, evtData->fCommonHeader[i]);
   }
 
   return ReadoutList(triggerMask);
 }
 
-AliHLTReadoutList AliHLTCTPData::ReadoutList(AliHLTUInt64_t  triggerMask) const
+AliHLTReadoutList AliHLTCTPData::ReadoutList(AliHLTTriggerMask_t  triggerMask) const
 {
   // take an 'OR' of all active trigger classes 
   AliHLTReadoutList list;
   for (int i=0; i<gkNCTPTriggerClasses; i++) {
     if (i>fClassIds.GetLast()) break;
-    if ((triggerMask&((AliHLTUInt64_t)0x1<<i))==0) continue;
+    if (! triggerMask.test(i)) continue;
     AliHLTReadoutList* tcrl=(AliHLTReadoutList*)fClassIds.At(i);
     list.OrEq(*tcrl);
   }
@@ -468,9 +482,27 @@ void AliHLTCTPData::Print(Option_t* /*option*/) const
   for (int i=0; i<gkNCTPTriggerClasses; i++) {
     if (i>=Counters().GetSize()) break;
     if (i>fClassIds.GetLast()) break;
-    if ((fMask&((AliHLTUInt64_t)0x1<<i))==0) continue;
+    if (! fMask.test(i)) continue;
     count++;
     cout << "\t" << i << "\t" << Name(i) << "\t" << Counter(i) << endl;
   }
   if (count==0) cout << "\t(none)" << endl;
 }
+
+
+std::string AliHLTCTPData::TriggerMaskToString(AliHLTTriggerMask_t mask) const
+{
+  AliHLTTriggerMask_t max(std::numeric_limits<unsigned long>::max());
+  int digits = std::numeric_limits<unsigned long>::digits;
+  int numberOfWords = (mask.size() + digits - 1)/digits;
+  std::stringstream stream;
+  stream << "0x";
+  stream << std::hex << std::right;
+  for(int i=numberOfWords-1; i>=0; --i){
+    stream.width(digits/4);
+    stream.fill('0');
+    stream << ((mask >> (digits*i)) & max).to_ulong() << " ";
+  }
+  return stream.str();
+}
+
index 42d8e16..231d5b5 100644 (file)
@@ -19,7 +19,7 @@
 #include "AliHLTLogging.h"
 #include "AliHLTDataTypes.h"
 #include "AliHLTReadoutList.h"
-
+#include <string>
 
 /**
  * @class AliHLTCTPData
@@ -72,7 +72,7 @@ class AliHLTCTPData: public TNamed, public AliHLTLogging
   int InitCTPTriggerClasses(const char* ctpString);
 
   /// etract the active trigger mask from the trigger data
-  static AliHLTUInt64_t ActiveTriggers(const AliHLTComponentTriggerData& trigData);
+  static AliHLTTriggerMask_t ActiveTriggers(const AliHLTComponentTriggerData& trigData);
 
   /**
    * Evaluate an expression of trigger class ids with respect to the trigger mask.
@@ -82,7 +82,7 @@ class AliHLTCTPData: public TNamed, public AliHLTLogging
   /**
    * Evaluate an expression of trigger class ids with respect to the trigger mask.
    */
-  bool EvaluateCTPTriggerClass(const char* expression, AliHLTUInt64_t triggerMask) const;
+  bool EvaluateCTPTriggerClass(const char* expression, AliHLTTriggerMask_t triggerMask) const;
 
   /**
    * Evaluate an expression of trigger class ids with respect to the current trigger mask.
@@ -120,13 +120,13 @@ class AliHLTCTPData: public TNamed, public AliHLTLogging
 
   /**
    * Increment counter for CTP trigger classes
-   * @param triggerPattern  corresponds to the 50bit trigger mask in the CDH
+   * @param triggerPattern  corresponds to the 100bit trigger mask in the CDH
    */
-  void Increment(AliHLTUInt64_t triggerPattern);
+  void Increment(AliHLTTriggerMask_t triggerPattern);
 
   /**
    * Increment counter for a CTP trigger class
-   * @param classIdx  index of the class in the 50bit trigger mask
+   * @param classIdx  index of the class in the 100bit trigger mask
    */
   void Increment(int classIdx);
 
@@ -147,7 +147,7 @@ class AliHLTCTPData: public TNamed, public AliHLTLogging
    * Return a readout list for the active trigger classes.
    * The list is an 'OR' of the active trugger classes.
    */
-  AliHLTReadoutList ReadoutList(AliHLTUInt64_t  triggerMask) const;
+  AliHLTReadoutList ReadoutList(AliHLTTriggerMask_t triggerMask) const;
 
   /**
    * Return a readout list for the active trigger classes.
@@ -162,17 +162,20 @@ class AliHLTCTPData: public TNamed, public AliHLTLogging
    */
   virtual void Print(Option_t* option = "") const;
 
-  AliHLTUInt64_t   Mask() const { return fMask; }
-  AliHLTUInt64_t   Triggers() const { return fTriggers; }
-  void             SetTriggers(AliHLTUInt64_t triggers) { fTriggers=triggers; }
-  void             SetTriggers(AliHLTComponentTriggerData trigData) {SetTriggers(ActiveTriggers(trigData));}
-  const TArrayL64& Counters() const { return fCounters; }
-  AliHLTUInt64_t   Counter(int index) const;
-  AliHLTUInt64_t   Counter(const char* classId) const;
-  const char*      Name(int index) const;
+  AliHLTTriggerMask_t   Mask() const { return fMask; }
+  AliHLTTriggerMask_t   Triggers() const { return fTriggers; }
+  void                  SetTriggers(AliHLTTriggerMask_t triggers) { fTriggers=triggers; }
+  void                  SetTriggers(AliHLTComponentTriggerData trigData) {SetTriggers(ActiveTriggers(trigData));}
+  const TArrayL64&      Counters() const { return fCounters; }
+  AliHLTUInt64_t        Counter(int index) const;
+  AliHLTUInt64_t        Counter(const char* classId) const;
+  const char*           Name(int index) const;
 
  protected:
  private:
+  /// Helper                                                                          
+  std::string TriggerMaskToString(AliHLTTriggerMask_t mask) const;
+
   /**
    * Add counters.
    * Base methods for operators.
@@ -193,11 +196,11 @@ class AliHLTCTPData: public TNamed, public AliHLTLogging
 
   int ReadMap() {return ReadMap(fMap);}
 
-  AliHLTUInt64_t fMask;      /// mask of initialized trigger classes
-  AliHLTUInt64_t fTriggers;  /// current trigger
-  TClonesArray   fClassIds;  /// array of trigger class ids
-  TArrayL64      fCounters;  /// trigger class counters
-  vector<unsigned> fMap;     //! index map for trigger expression evaluation
+  AliHLTTriggerMask_t fMask;      /// mask of initialized trigger classes
+  AliHLTTriggerMask_t fTriggers;  /// current trigger
+  TClonesArray        fClassIds;  /// array of trigger class ids
+  TArrayL64           fCounters;  /// trigger class counters
+  vector<unsigned>    fMap;     //! index map for trigger expression evaluation
 
   ClassDef(AliHLTCTPData, 2)
 };
index 1b64a0f..3617a3e 100644 (file)
@@ -31,7 +31,7 @@
 #include "AliHLTMessage.h"
 #include "AliHLTCTPData.h"
 #include "AliHLTErrorGuard.h"
-#include "AliRawDataHeader.h"
+#include "AliHLTCDHWrapper.h"
 #include "TString.h"
 #include "TMath.h"
 #include "TObjArray.h"
@@ -1899,10 +1899,10 @@ int AliHLTComponent::ProcessEvent( const AliHLTComponentEventData& evtData,
        {
          // We can actually get the event type from the CDH if it is valid.
          // Otherwise just use the specification of the input block.
-         const AliRawDataHeader* cdh;
+         AliHLTCDHWrapper cdh;
          if (ExtractTriggerData(trigData, NULL, NULL, &cdh, NULL) == 0)
          {
-           fEventType = ExtractEventTypeFromCDH(cdh);
+           fEventType = ExtractEventTypeFromCDH(&cdh);
          }
        }
 
@@ -2671,7 +2671,7 @@ int AliHLTComponent::ExtractTriggerData(
     const AliHLTComponentTriggerData& trigData,
     const AliHLTUInt8_t (**attributes)[gkAliHLTBlockDAttributeCount],
     AliHLTUInt64_t* status,
-    const AliRawDataHeader** cdh,
+    AliHLTCDHWrapper* const cdh,
     AliHLTReadoutList* readoutlist,
     bool printErrors
   )
@@ -2716,15 +2716,15 @@ int AliHLTComponent::ExtractTriggerData(
   AliHLTEventTriggerData* evtData = reinterpret_cast<AliHLTEventTriggerData*>(trigData.fData);
   assert(evtData != NULL);
   
-  // Check that the CDH has 8 words.
-  if (cdh != NULL and evtData->fCommonHeaderWordCnt != 8)
+  // Check that the CDH has the right number of words.
+  if (cdh != NULL and evtData->fCommonHeaderWordCnt != gkAliHLTCommonHeaderCount)
   {
     if (printErrors)
     {
       AliHLTLogging log;
       log.LoggingVarargs(kHLTLogError, Class_Name(), FUNCTIONNAME(), __FILE__, __LINE__,
           "Common Data Header (CDH) has wrong number of data words: %d but expected %d",
-          evtData->fCommonHeaderWordCnt, sizeof(AliRawDataHeader)/sizeof(AliHLTUInt32_t)
+          evtData->fCommonHeaderWordCnt, gkAliHLTCommonHeaderCount
         );
     }
     return -EBADMSG;
@@ -2757,8 +2757,7 @@ int AliHLTComponent::ExtractTriggerData(
   }
   if (cdh != NULL)
   {
-    const AliRawDataHeader* cdhptr = reinterpret_cast<const AliRawDataHeader*>(&evtData->fCommonHeader[0]);
-    *cdh = cdhptr;
+    *cdh = &(evtData->fCommonHeader[0]);
   }
   if (readoutlist != NULL)
   {
@@ -2767,10 +2766,9 @@ int AliHLTComponent::ExtractTriggerData(
   return 0;
 }
 
-AliHLTUInt32_t AliHLTComponent::ExtractEventTypeFromCDH(const AliRawDataHeader* cdh)
+AliHLTUInt32_t AliHLTComponent::ExtractEventTypeFromCDH(const AliHLTCDHWrapper* const cdh)
 {
   // see header file for function documentation
-  
   UChar_t l1msg = cdh->GetL1TriggerMessage();
   if ((l1msg & 0x1) == 0x0) return gkAliEventTypeData;
   // The L2SwC bit must be one if we got here, i.e. l1msg & 0x1 == 0x1.
index 85531d1..34de91b 100644 (file)
@@ -83,11 +83,11 @@ class TObjArray;
 class TMap;
 class TStopwatch;
 class TUUID;
-struct AliRawDataHeader;
 class AliHLTComponent;
 class AliHLTMemoryFile;
 class AliHLTCTPData;
 class AliHLTReadoutList;
+class AliHLTCDHWrapper;
 
 using std::vector;
 
@@ -756,7 +756,7 @@ class AliHLTComponent : public AliHLTLogging {
    * @note If any of the output parameters are set to NULL then the field is not set.
    *   For example, the following line will only fill the CDH pointer.
    *   \code
-   *     AliRawDataHeader* cdh;
+   *     AliHLTCDHWrapper cdh;
    *     ExtractTriggerData(trigData, NULL, NULL, &cdh, NULL);
    *   \endcode
    * @return zero on success or one of the following error codes on failure.
@@ -773,7 +773,7 @@ class AliHLTComponent : public AliHLTLogging {
       const AliHLTComponentTriggerData& trigData,
       const AliHLTUInt8_t (**attributes)[gkAliHLTBlockDAttributeCount],
       AliHLTUInt64_t* status,
-      const AliRawDataHeader** cdh,
+      AliHLTCDHWrapper* const cdh,
       AliHLTReadoutList* readoutlist,
       bool printErrors = false
     );
@@ -799,7 +799,7 @@ class AliHLTComponent : public AliHLTLogging {
    * @param [in] cdh  The Common Data Header to extract the event type from.
    * @return the event type code from the CDH.
    */
-  static AliHLTUInt32_t ExtractEventTypeFromCDH(const AliRawDataHeader* cdh);
+  static AliHLTUInt32_t ExtractEventTypeFromCDH(const AliHLTCDHWrapper* const cdh);
   
   /**
    * Stopwatch type for benchmarking.
index 91cad25..0eb4605 100644 (file)
@@ -70,8 +70,9 @@
  *  16       Adding data type for the meta data block to be forwarded by the
  *           TCPDumpSubscriber for the Common Data Header (CDH) and readout
  *           list information.
+ *  17       New CDH v3 (10 32bit words, 100 trigger classes, etc.)
  */
-#define ALIHLT_DATA_TYPES_VERSION 16
+#define ALIHLT_DATA_TYPES_VERSION 17
 
 //////////////////////////////////////////////////////////////////////////
 //
@@ -821,7 +822,9 @@ extern "C" {
   const int gkAliHLTBlockDAttributeCount = 8;
 
   /** field size of fCommonHeader */
-  const int gkAliHLTCommonHeaderCount = 8;
+  const int gkAliHLTCommonHeaderCountV2 = 8;
+  const int gkAliHLTCommonHeaderCountV3 = 10;
+  const int gkAliHLTCommonHeaderCount = gkAliHLTCommonHeaderCountV3;
 
   /** size of the DDL list first version */
   const int gkAliHLTDDLListSizeV0 = 30;
@@ -833,7 +836,12 @@ extern "C" {
   const int gkAliHLTDDLListSize = gkAliHLTDDLListSizeV1;
 
   /** Number of Trigger Classes of CTP in CDH */
-  const int gkNCTPTriggerClasses = 50;
+  const int gkNCTPTriggerClassesV2 = 50;
+  const int gkNCTPTriggerClassesV3 = 100;
+  const int gkNCTPTriggerClasses = gkNCTPTriggerClassesV3;
+
+  // make it also available as define for templates
+#define NCTPTRIGGERCLASSES 100
 
   /**
    * @struct AliHLTEventDDLV0
@@ -1428,6 +1436,9 @@ extern "C" {
 
 }
 
+#include <bitset>  
+typedef std::bitset<NCTPTRIGGERCLASSES> AliHLTTriggerMask_t;
+
 using namespace std;
 
 //////////////////////////////////////////////////////////////////////////
index 5795bb4..d1cb30f 100644 (file)
@@ -100,10 +100,10 @@ int AliHLTMisc::InitMagneticField() const
   return -EFAULT;
 }
 
-AliHLTUInt64_t AliHLTMisc::GetTriggerMask(AliRawReader* /*rawReader*/) const
+AliHLTTriggerMask_t AliHLTMisc::GetTriggerMask(AliRawReader* /*rawReader*/) const
 {
   // default method, functionality is implemented in the child class
-  return 0;
+  return AliHLTTriggerMask_t(0);
 }
 
 AliHLTUInt32_t AliHLTMisc::GetTimeStamp(AliRawReader* /*rawReader*/) const
index e9303c6..86657be 100644 (file)
@@ -72,7 +72,7 @@ class AliHLTMisc : public TObject {
 
   /// extract the triggermask from the rawreader
   /// NOTE: not to be used in the online system
-  virtual AliHLTUInt64_t GetTriggerMask(AliRawReader* rawReader) const;
+  virtual AliHLTTriggerMask_t GetTriggerMask(AliRawReader* rawReader) const;
 
   /// extract the timestamp from the rawreader
   /// NOTE: not to be used in the online system, use AliHLTComponent::GetTimeStamp()
index 32d71d9..6c9f844 100644 (file)
@@ -347,6 +347,14 @@ int AliHLTSystem::Run(Int_t iNofEvents, int bStop, AliHLTUInt64_t trgMask,
                      AliHLTUInt32_t timestamp, AliHLTUInt32_t eventtype,
                      AliHLTUInt32_t participatingDetectors)
 {
+  return Run(iNofEvents, bStop, AliHLTTriggerMask_t(trgMask), 
+            timestamp, eventtype, participatingDetectors);
+}
+
+int AliHLTSystem::Run(Int_t iNofEvents, int bStop, AliHLTTriggerMask_t trgMask,
+                     AliHLTUInt32_t timestamp, AliHLTUInt32_t eventtype,
+                     AliHLTUInt32_t participatingDetectors)
+{
   // see header file for class documentation
   int iResult=0;
   int iCount=0;
@@ -585,7 +593,7 @@ int AliHLTSystem::StartTasks()
   return iResult;
 }
 
-int AliHLTSystem::ProcessTasks(Int_t eventNo, AliHLTUInt64_t trgMask,
+int AliHLTSystem::ProcessTasks(Int_t eventNo, AliHLTTriggerMask_t trgMask,
          AliHLTUInt32_t timestamp, AliHLTUInt32_t eventtype,
          AliHLTUInt32_t participatingDetectors)
 {
@@ -819,7 +827,7 @@ int AliHLTSystem::Reconstruct(int nofEvents, AliRunLoader* runLoader,
        }
       } else {
       if ((iResult=AliHLTOfflineInterface::SetParamsToComponents(runLoader, rawReader))>=0) {
-       AliHLTUInt64_t trgMask=0x1;
+       AliHLTTriggerMask_t trgMask=0x1;
        AliHLTUInt32_t timestamp=kMaxUInt;
        AliHLTUInt32_t eventtype=0;
        if (runLoader==NULL) {
index 8ee934e..c5069e0 100644 (file)
@@ -219,6 +219,10 @@ class AliHLTSystem : public AliHLTLogging {
          AliHLTUInt32_t timestamp, AliHLTUInt32_t eventtype,
          AliHLTUInt32_t participatingDetectors = 0);
 
+  int Run(Int_t iNofEvents, int bStop, AliHLTTriggerMask_t trgMask,
+         AliHLTUInt32_t timestamp, AliHLTUInt32_t eventtype,
+         AliHLTUInt32_t participatingDetectors = 0);
+
   /**
    * Run the tasklist
    * Somehow the 64bit variable/default value did not work out on mac.
@@ -281,7 +285,7 @@ class AliHLTSystem : public AliHLTLogging {
    * The @ref AliHLTTask::ProcessTask method is called for each task.
    * @return neg error code if failed
    */
-  int ProcessTasks(Int_t eventNo, AliHLTUInt64_t trgMask,
+  int ProcessTasks(Int_t eventNo, AliHLTTriggerMask_t trgMask,
                   AliHLTUInt32_t timestamp, AliHLTUInt32_t eventtype,
                   AliHLTUInt32_t participatingDetectors = 0);
 
index f2a4e1b..2fd75b7 100644 (file)
@@ -442,7 +442,7 @@ int AliHLTTask::EndRun()
   return iResult;
 }
 
-int AliHLTTask::ProcessTask(Int_t eventNo, AliHLTUInt32_t eventType, AliHLTUInt64_t trgMask,
+int AliHLTTask::ProcessTask(Int_t eventNo, AliHLTUInt32_t eventType, AliHLTTriggerMask_t trgMask,
                            AliHLTUInt32_t timestamp, AliHLTUInt32_t participatingDetectors)
 {
   // see header file for function documentation
@@ -588,8 +588,11 @@ int AliHLTTask::ProcessTask(Int_t eventNo, AliHLTUInt32_t eventType, AliHLTUInt6
       }
       evtTrigData.fCommonHeader[1] = AliHLTUInt32_t(l1msg) << 14;
       evtTrigData.fCommonHeader[3] = ((l1msg & 0x1) == 0x1) ? (participatingDetectors & 0xFFFFFF) : 0x0;
-      evtTrigData.fCommonHeader[5]=trgMask&0xffffffff;
-      evtTrigData.fCommonHeader[6]=(trgMask>>32)&0x3ffff;
+      evtTrigData.fCommonHeader[5] = (trgMask & AliHLTTriggerMask_t(0xffffffff)).to_ulong();
+      evtTrigData.fCommonHeader[6] = ((trgMask>>32) & AliHLTTriggerMask_t(0x3ffff)).to_ulong();
+      evtTrigData.fCommonHeader[7] = ((trgMask>>50) & AliHLTTriggerMask_t(0xffffffff)).to_ulong();
+      evtTrigData.fCommonHeader[8] = ((trgMask>>72) & AliHLTTriggerMask_t(0x3ffff)).to_ulong();
+
       trigData.fData=&evtTrigData;
       iLastOutputDataSize=iOutputDataSize;
       AliHLTUInt32_t size=iOutputDataSize;
index 65b01bc..23d19fe 100644 (file)
@@ -203,7 +203,7 @@ class AliHLTTask : public TObject, public AliHLTLogging {
    * The @ref StartRun method must be called before.
    */
   int ProcessTask(Int_t eventNo, AliHLTUInt32_t eventType,
-                 AliHLTUInt64_t trgMask, AliHLTUInt32_t timestamp,
+                 AliHLTTriggerMask_t trgMask, AliHLTUInt32_t timestamp,
                  AliHLTUInt32_t participatingDetectors = 0);
 
   /**
index 06af6f0..32ab1e5 100644 (file)
@@ -25,6 +25,7 @@
 #include "AliRawReader.h"
 #include "AliDAQ.h"
 #include "AliLog.h"
+#include "AliHLTCDHWrapper.h" 
 #include <cerrno>
 #include <cassert>
 #include <list>
@@ -245,12 +246,19 @@ int AliHLTRawReaderPublisherComponent::GetEvent(const AliHLTComponentEventData&
     }
     list<int> processedIds;
     while (pRawReader->ReadHeader() && (iResult>=0 || iResult==-ENOSPC)) {
-      const AliRawDataHeader* pHeader=pRawReader->GetDataHeader();
-      if (pHeader==NULL) {
+      const AliRawDataHeader* pHeaderV2=pRawReader->GetDataHeader();
+      const AliRawDataHeaderV3* pHeaderV3=pRawReader->GetDataHeaderV3();
+      AliHLTCDHWrapper pHeader;
+      if(pHeaderV2) {
+       pHeader=pHeaderV2;
+      } else if (pHeaderV3) {
+       pHeader=pHeaderV3;
+      } else {
        HLTError("can not get data header from RawReader, skipping data block ...");
        continue;
       }
-      unsigned int readSize=pRawReader->GetDataSize()+sizeof(AliRawDataHeader);
+      unsigned int headerSize=pHeader.GetHeaderSize();
+      unsigned int readSize=pRawReader->GetDataSize()+headerSize;
       int id=pRawReader->GetEquipmentId();
       if (fMinEquId>id || fMaxEquId<id) {
        AliError(Form("id %d returned from RawReader is outside range [%d,%d]", id, fMinEquId, fMaxEquId));
@@ -265,10 +273,10 @@ int AliHLTRawReaderPublisherComponent::GetEvent(const AliHLTComponentEventData&
       }
       if (!isSelected) continue;
       if (readSize+offset<=capacity) {
-       memcpy(outputPtr+offset, pHeader, sizeof(AliRawDataHeader));
-       if (readSize>sizeof(AliRawDataHeader)) {
-         if (!pRawReader->ReadNext(outputPtr+offset+sizeof(AliRawDataHeader), readSize-sizeof(AliRawDataHeader))) {
-           AliError(Form("error reading %ld bytes from RawReader %p", readSize-sizeof(AliRawDataHeader), pRawReader));
+       memcpy(outputPtr+offset, pHeader.GetHeader(), headerSize);
+       if (readSize>headerSize) {
+         if (!pRawReader->ReadNext(outputPtr+offset+headerSize, readSize-headerSize)) {
+           AliError(Form("error reading %d bytes from RawReader %p", readSize-headerSize, pRawReader));
            iResult=-ENODATA;
            break;
          }
@@ -293,26 +301,42 @@ int AliHLTRawReaderPublisherComponent::GetEvent(const AliHLTComponentEventData&
     }
     if (!fSkipEmpty && processedIds.size()!=size_t(fMaxEquId-fMinEquId+1)) {
       // add further empty data blocks
-      AliRawDataHeader header;
-      header.fSize=sizeof(AliRawDataHeader);
-      const UInt_t* triggermask=pRawReader->GetTriggerPattern();
-      if (triggermask) {
-       header.fTriggerClassLow=triggermask[0];
-       header.fROILowTriggerClassHigh=triggermask[1];
+      AliHLTCDHWrapper header;
+      if(pRawReader->GetVersion()==2){
+       AliRawDataHeader headerV2;
+       headerV2.fSize=sizeof(AliRawDataHeader);
+       const UInt_t* triggermask=pRawReader->GetTriggerPattern();
+       if (triggermask) {
+         headerV2.fTriggerClassLow=triggermask[0];
+         headerV2.fROILowTriggerClassHigh=triggermask[1];
+       }
+       header=&headerV2;
+      } else if (pRawReader->GetVersion()==3){
+       AliRawDataHeaderV3 headerV3;
+        headerV3.fSize=sizeof(AliRawDataHeaderV3);
+        const UInt_t* triggermask=pRawReader->GetTriggerPattern();
+        if (triggermask) {
+          headerV3.fTriggerClassLow=triggermask[0];
+         headerV3.fTriggerClassesMiddleLow=triggermask[1] & 0x3FFFF;
+         headerV3.fTriggerClassesMiddleHigh= (triggermask[1]>>18) | (triggermask[2]<<14);
+          headerV3.fROILowTriggerClassHigh=(triggermask[2]>>18) | (triggermask[3]<<14);
+        }
+        header=&headerV3;
       }
+      unsigned int headerSize=header.GetHeaderSize();
       processedIds.sort();
       list<int>::iterator curr=processedIds.begin();
       for (int id=fMinEquId; id<=fMaxEquId; id++) {
        if (curr!=processedIds.end() && *curr<=id) {
          curr++;
        } else {
-         if (sizeof(AliRawDataHeader)<=capacity-offset) {
+         if (headerSize<=capacity-offset) {
            HLTInfo("add empty data block for equipment id %d", id);
-           memcpy(outputPtr+offset, &header, sizeof(AliRawDataHeader));
+           memcpy(outputPtr+offset, header.GetHeader(), headerSize);
            AliHLTComponentBlockData bd;
            FillBlockData( bd );
            bd.fOffset = offset;
-           bd.fSize = sizeof(AliRawDataHeader);
+           bd.fSize = headerSize;
            bd.fDataType = fDataType;
            if (fSpecification == kAliHLTVoidDataSpec) {
              GetSpecificationFromEquipmentId(id, bd.fSpecification);
@@ -322,10 +346,10 @@ int AliHLTRawReaderPublisherComponent::GetEvent(const AliHLTComponentEventData&
            outputBlocks.push_back( bd );
          } else {
            // we keep the loop going in order to collect the full size
-           fMaxSize=offset+sizeof(AliRawDataHeader);
+           fMaxSize=offset+headerSize;
            iResult=-ENOSPC;
          }
-         offset+=sizeof(AliRawDataHeader);
+         offset+=headerSize;
        }
       }
     }
index c9aee29..48bcbf5 100644 (file)
@@ -190,8 +190,8 @@ int AliHLTReadoutListDumpComponent::FillReadoutListVsCTP(TH2I* histo, const AliH
   if (list->BufferSize()!=sizeof(AliHLTEventDDL)) return -EBADF;
   if (list->Buffer()->fCount!=(unsigned)gkAliHLTDDLListSize) return -EBADF;
 
-  AliHLTUInt64_t triggerMask=AliHLTCTPData::ActiveTriggers(*trigData);
-  AliHLTUInt64_t bit0=0x1;
+  AliHLTTriggerMask_t triggerMask=AliHLTCTPData::ActiveTriggers(*trigData);
+  AliHLTTriggerMask_t bit0=0x1;
   for (int word=0; word<gkAliHLTDDLListSize; word++) {
     for (unsigned bit=0; bit<sizeof(AliHLTUInt32_t)*8; bit++) {
       if (list->Buffer()->fList[word]&0x1<<bit) {
index dd3402b..ddcb261 100644 (file)
@@ -26,7 +26,6 @@
 #include "AliCDBEntry.h"
 #include "AliCDBPath.h"
 #include "AliCDBManager.h"
-#include "AliRawDataHeader.h"
 #include "TFile.h"
 #include <sys/stat.h>
 #include <sys/types.h>
@@ -125,16 +124,12 @@ AliHLTEMCALDigitMakerComponent::GetOutputDataSize(unsigned long& constBase, doub
 
 int 
 AliHLTEMCALDigitMakerComponent::DoEvent(const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
-                                       AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size,
+                                       AliHLTComponentTriggerData& /* trigData */, AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size,
                                        std::vector<AliHLTComponentBlockData>& outputBlocks)
 {
 
-       //patch in order to skip calib events
-  const AliRawDataHeader* cdh = NULL;
-  ExtractTriggerData(trigData, NULL, NULL, &cdh, NULL, true);
-       AliHLTUInt64_t triggerMask = cdh->GetTriggerClasses();
-       if(triggerMask == 0) return 0;
-
+  //patch in order to skip calib events
+  if(! IsDataEvent()) return 0;
 
   //see header file for documentation
   UInt_t offset           = 0; 
index 17c8fc4..a45fccd 100644 (file)
@@ -33,7 +33,7 @@
 #include "AliHLTLogging.h"
 #include "AliHLTSystem.h"
 #include "AliHLTDefinitions.h"
-#include "AliRawDataHeader.h"
+#include "AliRawDataHeaderV3.h"
 #include "AliMUONTrackerDDLDecoderEventHandler.h"
 #include "AliMUONConstants.h"
 #include "AliMUONMCDataInterface.h"
@@ -119,7 +119,7 @@ void AliHLTMUONDigitPublisherComponent::GetOutputDataSize(
        /// Returns an estimate of the expected output data size.
        
        // estimated as max number of channels * raw data word size + max headers size.
-       constBase = sizeof(AliRawDataHeader) + 65536*sizeof(UInt_t)
+       constBase = sizeof(AliRawDataHeaderV3) + 65536*sizeof(UInt_t)
                + sizeof(AliMUONBlockHeaderStruct)*2 + sizeof(AliMUONDSPHeaderStruct)*10
                + sizeof(AliMUONBusPatchHeaderStruct) * 50;
        inputMultiplier = 0;
@@ -907,17 +907,17 @@ int AliHLTMUONDigitPublisherComponent::WriteTrackerDDL(
   blockHeader.SetDataKey(blockHeader.GetDefaultDataKey());
   dspHeader.SetDataKey(dspHeader.GetDefaultDataKey());
   
-  if (outBufferSize < sizeof(AliRawDataHeader))
+  if (outBufferSize < sizeof(AliRawDataHeaderV3))
   {
        HLTError("The output buffer size is too small to write output."
                " It is only %d bytes, but we need at least %d bytes.",
-               outBufferSize, sizeof(AliRawDataHeader)
+               outBufferSize, sizeof(AliRawDataHeaderV3)
        );
        return -ENOBUFS;
   }
-  AliRawDataHeader* header = reinterpret_cast<AliRawDataHeader*>(outBuffer);
+  AliRawDataHeaderV3* header = reinterpret_cast<AliRawDataHeaderV3*>(outBuffer);
   // Fill header with default values.
-  *header = AliRawDataHeader();
+  *header = AliRawDataHeaderV3();
   AliRunLoader* runloader = AliRunLoader::Instance();
   if (runloader != NULL)
   {
@@ -926,11 +926,13 @@ int AliHLTMUONDigitPublisherComponent::WriteTrackerDDL(
       AliCentralTrigger *aCTP = runloader->GetTrigger();
       ULong64_t mask = aCTP->GetClassMask();
       header->SetTriggerClass(mask);
+      mask = aCTP->GetClassMaskNext50();
+      header->SetTriggerClassNext50(mask);
     }
   }
   
   Int_t* buffer = reinterpret_cast<Int_t*>(header+1);
-  Int_t endOfBuffer = (outBufferSize - sizeof(AliRawDataHeader)) / sizeof(Int_t);
+  Int_t endOfBuffer = (outBufferSize - sizeof(AliRawDataHeaderV3)) / sizeof(Int_t);
   
   // buffer size (max'ed out)
   // (((43 manus max per bus patch *64 channels + 4 bus patch words) * 5 bus patch 
@@ -955,7 +957,7 @@ int AliHLTMUONDigitPublisherComponent::WriteTrackerDDL(
       HLTError("The output buffer size is too small to write output."
                " It is only %d bytes, but we need at least %d bytes.",
                outBufferSize,
-               sizeof(AliRawDataHeader) + (index+length)*sizeof(UInt_t)
+               sizeof(AliRawDataHeaderV3) + (index+length)*sizeof(UInt_t)
       );
       return -ENOBUFS;
     }
@@ -974,7 +976,7 @@ int AliHLTMUONDigitPublisherComponent::WriteTrackerDDL(
         HLTError("The output buffer size is too small to write output."
                  " It is only %d bytes, but we need at least %d bytes.",
                  outBufferSize,
-                 sizeof(AliRawDataHeader) + (index+dspHeaderLength)*sizeof(UInt_t)
+                 sizeof(AliRawDataHeaderV3) + (index+dspHeaderLength)*sizeof(UInt_t)
         );
         return -ENOBUFS;
       }
@@ -1004,7 +1006,7 @@ int AliHLTMUONDigitPublisherComponent::WriteTrackerDDL(
           HLTError("The output buffer size is too small to write output."
                    " It is only %d bytes, but we need at least %d bytes.",
                    outBufferSize,
-                   sizeof(AliRawDataHeader) + (index+busHeaderLength)*sizeof(UInt_t)
+                   sizeof(AliRawDataHeaderV3) + (index+busHeaderLength)*sizeof(UInt_t)
           );
           return -ENOBUFS;
         }
@@ -1022,7 +1024,7 @@ int AliHLTMUONDigitPublisherComponent::WriteTrackerDDL(
             HLTError("The output buffer size is too small to write output."
                      " It is only %d bytes, but we need at least %d bytes.",
                      outBufferSize,
-                     sizeof(AliRawDataHeader) + (index+busLength)*sizeof(UInt_t)
+                     sizeof(AliRawDataHeaderV3) + (index+busLength)*sizeof(UInt_t)
             );
             return -ENOBUFS;
           }
@@ -1046,7 +1048,7 @@ int AliHLTMUONDigitPublisherComponent::WriteTrackerDDL(
         HLTError("The output buffer size is too small to write output."
                  " It is only %d bytes, but we need at least %d bytes.",
                  outBufferSize,
-                 sizeof(AliRawDataHeader) + (index+1)*sizeof(UInt_t)
+                 sizeof(AliRawDataHeaderV3) + (index+1)*sizeof(UInt_t)
         );
         return -ENOBUFS;
       }
@@ -1083,7 +1085,7 @@ int AliHLTMUONDigitPublisherComponent::WriteTrackerDDL(
     HLTError("The output buffer size is too small to write output."
              " It is only %d bytes, but we need at least %d bytes.",
              outBufferSize,
-             sizeof(AliRawDataHeader) + (index+2)*sizeof(UInt_t)
+             sizeof(AliRawDataHeaderV3) + (index+2)*sizeof(UInt_t)
     );
     return -ENOBUFS;
   }
@@ -1094,7 +1096,7 @@ int AliHLTMUONDigitPublisherComponent::WriteTrackerDDL(
   buffer[index++] = blockHeader.GetDdlDataKey();
   totalDDLLength  += 2;
   
-  header->fSize = (totalDDLLength) * sizeof(Int_t) + sizeof(AliRawDataHeader);
+  header->fSize = (totalDDLLength) * sizeof(Int_t) + sizeof(AliRawDataHeaderV3);
   outBufferSize = header->fSize;
   
   return 0;
@@ -1114,17 +1116,17 @@ int AliHLTMUONDigitPublisherComponent::WriteTriggerDDL(
   AliMpDDLStore* ddlStore = AliMpDDLStore::Instance();
   assert(ddlStore != NULL);
   
-  if (outBufferSize < sizeof(AliRawDataHeader))
+  if (outBufferSize < sizeof(AliRawDataHeaderV3))
   {
        HLTError("The output buffer size is too small to write output."
                " It is only %d bytes, but we need at least %d bytes.",
-               outBufferSize, sizeof(AliRawDataHeader)
+               outBufferSize, sizeof(AliRawDataHeaderV3)
        );
        return -ENOBUFS;
   }
-  AliRawDataHeader* header = reinterpret_cast<AliRawDataHeader*>(outBuffer);
+  AliRawDataHeaderV3* header = reinterpret_cast<AliRawDataHeaderV3*>(outBuffer);
   // Fill header with default values.
-  *header = AliRawDataHeader();
+  *header = AliRawDataHeaderV3();
   AliRunLoader* runloader = AliRunLoader::Instance();
   if (runloader != NULL)
   {
@@ -1189,22 +1191,22 @@ int AliHLTMUONDigitPublisherComponent::WriteTriggerDDL(
   }
   if(scalarEvent)
   {
-    if (outBufferSize < sizeof(AliRawDataHeader) + kScalerBufferSize)
+    if (outBufferSize < sizeof(AliRawDataHeaderV3) + kScalerBufferSize)
     {
       HLTError("The output buffer size is too small to write output."
                " It is only %d bytes, but we need at least %d bytes.",
-               outBufferSize, sizeof(AliRawDataHeader) + kScalerBufferSize
+               outBufferSize, sizeof(AliRawDataHeaderV3) + kScalerBufferSize
       );
       return -ENOBUFS;
     }
   }
   else
   {
-    if (outBufferSize < sizeof(AliRawDataHeader) + kBufferSize)
+    if (outBufferSize < sizeof(AliRawDataHeaderV3) + kBufferSize)
     {
       HLTError("The output buffer size is too small to write output."
                " It is only %d bytes, but we need at least %d bytes.",
-               outBufferSize, sizeof(AliRawDataHeader) + kBufferSize
+               outBufferSize, sizeof(AliRawDataHeaderV3) + kBufferSize
       );
       return -ENOBUFS;
     }
@@ -1392,7 +1394,7 @@ int AliHLTMUONDigitPublisherComponent::WriteTriggerDDL(
       
     } // Regional card
 
-  header->fSize = index * sizeof(Int_t) + sizeof(AliRawDataHeader);
+  header->fSize = index * sizeof(Int_t) + sizeof(AliRawDataHeaderV3);
   outBufferSize = header->fSize;
 
   return 0;
index 2abbee5..74bcfdc 100644 (file)
 #include "AliHLTMUONClustersBlockStruct.h"
 #include "AliHLTMUONChannelsBlockStruct.h"
 #include "AliHLTMUONUtils.h"
-#include "AliRawDataHeader.h"
 #include <cassert>
 
 
 const AliHLTInt32_t AliHLTMUONHitReconstructor::fgkDetectorId = 0xA00;
 const AliHLTInt32_t AliHLTMUONHitReconstructor::fgkDDLOffSet = 0;
 const AliHLTInt32_t AliHLTMUONHitReconstructor::fgkNofDDL = 20;
-const AliHLTInt32_t AliHLTMUONHitReconstructor::fgkDDLHeaderSize = 8;
+const AliHLTInt32_t AliHLTMUONHitReconstructor::fgkDDLHeaderSize = gkAliHLTCommonHeaderCount;
 const AliHLTInt32_t AliHLTMUONHitReconstructor::fgkLutLine = 59648 + 1;
 const AliHLTInt32_t AliHLTMUONHitReconstructor::fgkMaxNofDataPerDetElem = 3000;
 const AliHLTInt32_t AliHLTMUONHitReconstructor::fgkNofDetElemInDDL[20] =   {  2,   2,   2,   2, 
@@ -1997,7 +1996,7 @@ void AliHLTMUONHitReconstructor::AliHLTMUONRawDecoder::OnError(ErrorCode code, c
        }
        if (fDontPrintParityErrors and code == kParityError) return;
        
-       long bytepos = long(location) - long(fkBufferStart) + sizeof(AliRawDataHeader);
+       long bytepos = long(location) - long(fkBufferStart);
        if (fWarnOnly or (fPrintParityErrorAsWarning and code == kParityError))
        {
                HLTWarning("There is a problem with decoding the raw data."
index b29eac2..5316d13 100644 (file)
@@ -47,7 +47,6 @@
 #include "AliHLTMUONConstants.h"
 #include "AliHLTMUONCalculations.h"
 #include "AliMUONConstants.h"
-#include "AliRawDataHeader.h"
 #include <vector>
 #include <cassert>
 
@@ -1126,7 +1125,7 @@ void AliHLTMUONTriggerReconstructor::AliDecoderHandler::OnError(
 {
        /// Logs an error message if there was a decoding problem with the DDL payload.
        
-       long bytepos = long(location) - long(fBufferStart) + sizeof(AliRawDataHeader);
+        long bytepos = long(location) - long(fBufferStart);
        if (code == kWrongEventType)
        {
                fHadWrongEventTypeError = true;
index 795db04..2d5d311 100644 (file)
@@ -32,6 +32,7 @@
 #include "AliHLTMUONUtils.h"
 #include "AliHLTMUONDataBlockWriter.h"
 #include "AliRawDataHeader.h"
+#include "AliHLTCDHWrapper.h"
 #include "AliCDBManager.h"
 #include "AliCDBStorage.h"
 #include "AliGeomManager.h"
@@ -676,22 +677,23 @@ int AliHLTMUONTriggerReconstructorComponent::DoEvent(
                }
 
                AliHLTUInt32_t totalDDLSize = blocks[n].fSize;
-               if (totalDDLSize < sizeof(AliRawDataHeader))
+               AliHLTCDHWrapper header(blocks[n].fPtr);
+               if (totalDDLSize < sizeof(AliRawDataHeader) &&
+                   totalDDLSize < header.GetHeaderSize()) // if cdh v3
                {
                        HLTError("Raw data block %d is %d bytes in size and is too short to"
-                                " possibly contain valid DDL raw data. We expect it to have"
-                                " at least %d bytes for the commond data header.",
-                               n, totalDDLSize, sizeof(AliRawDataHeader)
+                                " possibly contain valid DDL raw data.",
+                               n, totalDDLSize
                        );
                        continue;
                }
-               AliRawDataHeader* header = reinterpret_cast<AliRawDataHeader*>(blocks[n].fPtr);
-               AliHLTUInt32_t payloadSize = totalDDLSize - sizeof(AliRawDataHeader);
-               AliHLTUInt8_t* buffer = reinterpret_cast<AliHLTUInt8_t*>(header + 1);
+               AliHLTUInt32_t payloadSize = totalDDLSize - header.GetHeaderSize();
+               AliHLTUInt8_t* buffer = reinterpret_cast<AliHLTUInt8_t*>(blocks[n].fPtr);
+               buffer += header.GetHeaderSize();
                AliHLTUInt32_t nofTrigRec = block.MaxNumberOfEntries();
                
                // Decode if this is a scalar event or not.
-               bool scalarEvent = ((header->GetL1TriggerMessage() & 0x1) == 0x1);
+               bool scalarEvent = ((header.GetL1TriggerMessage() & 0x1) == 0x1);
                
                // Remember: the following does NOT change the mapping!
                // It is just to generate unique trigger record IDs.
index 6cf07cd..bda3304 100644 (file)
@@ -33,6 +33,7 @@
 #include "AliHLTSystem.h"
 #include "AliHLTDefinitions.h"
 #include "AliRawDataHeader.h"
+#include "AliHLTCDHWrapper.h"
 #include "AliMUONConstants.h"
 #include "AliMUONTrackerDDLDecoder.h"
 #include "AliMUONTrackerDDLDecoderEventHandler.h"
@@ -1442,7 +1443,7 @@ namespace
                ///      where the problem was found.
                /// \param handler  The decoder handler object.
                
-               long bytepos = long(location) - long(fBufferStart) + sizeof(AliRawDataHeader);
+                long bytepos = long(location) - long(fBufferStart);
                
                // create data type string.
                char dataType[kAliHLTComponentDataTypefIDsize+kAliHLTComponentDataTypefOriginSize+2];
@@ -1752,28 +1753,26 @@ bool AliHLTMUONDataCheckerComponent::CheckRawDataBlock(
        
        // Check the DDL common data header.
        AliHLTUInt32_t totalDDLSize = block.fSize;
-       if (totalDDLSize < sizeof(AliRawDataHeader))
+       AliHLTCDHWrapper header(block.fPtr);
+       if (totalDDLSize < sizeof(AliRawDataHeader) &&
+           totalDDLSize < header.GetHeaderSize()) // if cdh v3
        {
                HLTError("Problem found with data block %d, fDataType = '%s',"
                         " fPtr = %p and fSize = %u bytes."
                         " Assuming this is a DDL raw data block."
                         " Problem: The size of the data block is too short to contain"
                         " a valid common DDL data header. Size of buffer is only %d"
-                        " bytes, but expected at least %d bytes.",
+                        " bytes.",
                        blockNumber,
                        DataType2Text(block.fDataType).c_str(),
                        block.fPtr,
                        block.fSize,
-                       totalDDLSize,
-                       sizeof(AliRawDataHeader)
+                       totalDDLSize
                );
                return false;
        }
        
-       const AliRawDataHeader* header =
-               reinterpret_cast<const AliRawDataHeader*>(block.fPtr);
-       
-       if (header->GetVersion() != 2)
+       if (header.GetVersion() < 2)
        {
                HLTError("Problem found with data block %d, fDataType = '%s',"
                         " fPtr = %p and fSize = %u bytes."
@@ -1784,12 +1783,12 @@ bool AliHLTMUONDataCheckerComponent::CheckRawDataBlock(
                        DataType2Text(block.fDataType).c_str(),
                        block.fPtr,
                        block.fSize,
-                       int( header->GetVersion() )
+                       int( header.GetVersion() )
                );
                result = false;
        }
        
-       if (header->fSize != 0xFFFFFFFF and header->fSize != block.fSize)
+       if (header.GetDataSize() != 0xFFFFFFFF and header.GetDataSize() != block.fSize)
        {
                HLTError("Problem found with data block %d, fDataType = '%s',"
                         " fPtr = %p and fSize = %u bytes."
@@ -1802,56 +1801,19 @@ bool AliHLTMUONDataCheckerComponent::CheckRawDataBlock(
                        block.fPtr,
                        block.fSize,
                        block.fSize,
-                       header->fSize
-               );
-               result = false;
-       }
-       
-       if (header->fSize != 0xFFFFFFFF and header->fSize != block.fSize)
-       {
-               HLTError("Problem found with data block %d, fDataType = '%s',"
-                        " fPtr = %p and fSize = %u bytes."
-                        " Assuming this is a DDL raw data block."
-                        " Problem: The common DDL data header indicates an"
-                        " incorrect DDL buffer size. Expected %d bytes but"
-                        " size reported in header is %d bytes.",
-                       blockNumber,
-                       DataType2Text(block.fDataType).c_str(),
-                       block.fPtr,
-                       block.fSize,
-                       block.fSize,
-                       header->fSize
-               );
-               result = false;
-       }
-       
-       // Check that the bits that should be zero in the CDH are infact zero.
-       if ((header->fWord2 & 0x00C03000) != 0 or
-           (header->fEventID2 & 0xFF000000) != 0 or
-           (header->fStatusMiniEventID & 0xF0000000) != 0 or
-           (header->fROILowTriggerClassHigh & 0x0FFC0000) != 0
-          )
-       {
-               HLTError("Problem found with data block %d, fDataType = '%s',"
-                        " fPtr = %p and fSize = %u bytes."
-                        " Assuming this is a DDL raw data block."
-                        " Problem: The common DDL data header has non-zero"
-                        " bits that are reserved and must be set to zero.",
-                       blockNumber,
-                       DataType2Text(block.fDataType).c_str(),
-                       block.fPtr,
-                       block.fSize
+                       header.GetDataSize()
                );
                result = false;
        }
        
-       AliHLTUInt32_t payloadSize = block.fSize - sizeof(AliRawDataHeader);
+       AliHLTUInt32_t payloadSize = block.fSize - header.GetHeaderSize();
        const AliHLTUInt8_t* payload =
-               reinterpret_cast<const AliHLTUInt8_t*>(header + 1);
+               reinterpret_cast<const AliHLTUInt8_t*>(block.fPtr);
+       payload += header.GetHeaderSize();
        
        if (AliHLTMUONUtils::IsTriggerDDL(block.fSpecification))
        {
-               bool scalarEvent = ((header->GetL1TriggerMessage() & 0x1) == 0x1);
+               bool scalarEvent = ((header.GetL1TriggerMessage() & 0x1) == 0x1);
                AliMUONTriggerDDLDecoder<AliHLTMUONTriggerDecoderHandler> decoder;
                decoder.ExitOnError(false);
                decoder.TryRecover(false);
index 75ee3b2..c86ac03 100644 (file)
@@ -32,6 +32,7 @@
 #include "AliCDBEntry.h"
 #include "AliCDBManager.h"
 #include "AliRawDataHeader.h"
+#include "AliHLTCDHWrapper.h"
 #include "TTimeStamp.h"
 #include <cstdlib>
 #include <cstring>
@@ -386,11 +387,13 @@ bool AliHLTMUONRawDataHistoComponent::ProcessTrackerDDL(const AliHLTComponentBlo
        fTrackerDecoder.GetHandler().ManuHist(fManuHist[ddl]);
        fTrackerDecoder.GetHandler().SignalHist(fSignalHist[ddl]);
        
-       if (block->fSize >= sizeof(AliRawDataHeader))
+       AliHLTCDHWrapper cdh(block->fPtr);
+       if (block->fSize >= sizeof(AliRawDataHeader) && 
+           block->fSize >= cdh.GetHeaderSize()) // in case if cdh v3
        {
                AliHLTUInt8_t* payload = reinterpret_cast<AliHLTUInt8_t*>(block->fPtr)
-                       + sizeof(AliRawDataHeader);
-               UInt_t payloadSize = UInt_t(block->fSize) - sizeof(AliRawDataHeader);
+                 + cdh.GetHeaderSize();
+               UInt_t payloadSize = UInt_t(block->fSize) - cdh.GetHeaderSize();
                return fTrackerDecoder.Decode(payload, payloadSize);
        }
        else
@@ -414,12 +417,14 @@ bool AliHLTMUONRawDataHistoComponent::ProcessTriggerDDL(const AliHLTComponentBlo
        
        fTriggerDecoder.GetHandler().ErrorHist(fErrorHist[ddl]);
        
-       if (block->fSize >= sizeof(AliRawDataHeader))
+       AliHLTCDHWrapper cdh(block->fPtr);
+       if (block->fSize >= sizeof(AliRawDataHeader) &&
+           block->fSize >= cdh.GetHeaderSize()) // in case if cdh v3)
        {
-               AliRawDataHeader* header = reinterpret_cast<AliRawDataHeader*>(block->fPtr);
-               AliHLTUInt8_t* payload = reinterpret_cast<AliHLTUInt8_t*>(header+1);
-               UInt_t payloadSize = UInt_t(block->fSize) - sizeof(AliRawDataHeader);
-               bool scalarEvent = ((header->GetL1TriggerMessage() & 0x1) == 0x1);
+               AliHLTUInt8_t* payload = reinterpret_cast<AliHLTUInt8_t*>(block->fPtr);
+               payload += cdh.GetHeaderSize();
+               UInt_t payloadSize = UInt_t(block->fSize) - cdh.GetHeaderSize();
+               bool scalarEvent = ((cdh.GetL1TriggerMessage() & 0x1) == 0x1);
                return fTriggerDecoder.Decode(payload, payloadSize, scalarEvent);
        }
        else
index d4bc2bb..c7ef61e 100644 (file)
@@ -29,7 +29,7 @@
 #include "TArrayC.h"
 #include "TRandom.h"
 #include "TDatime.h"
-#include "AliRawDataHeader.h"
+#include "AliRawDataHeaderV3.h"
 #include "AliHLTAltroEncoder.h"
 
 /** ROOT macro for the implementation of ROOT specific class methods */
@@ -249,13 +249,13 @@ int AliHLTAltroGenerator::GetData(AliHLTUInt8_t* pBuffer, int size)
   return dataPos;
 }
 
-int AliHLTAltroGenerator::SetCDH(AliRawDataHeader* pCDH, int size)
+int AliHLTAltroGenerator::SetCDH(AliRawDataHeaderV3* pCDH, int size)
 {
   // see header file for class documentation
   int iResult=0;
   if (pCDH && size>0) {
     if (fpCDH) delete[] fpCDH;
-    fpCDH=new AliRawDataHeader;
+    fpCDH=new AliRawDataHeaderV3;
     if (fpCDH) {
       memcpy(fpCDH, pCDH, size);
       fCDHSize=size;
index ddba747..6fae0b3 100644 (file)
@@ -24,7 +24,7 @@
 #include <vector>
 #include <ostream>
 
-struct AliRawDataHeader;
+struct AliRawDataHeaderV3;
 class TArrayS;
 class TArrayC;
 class TRandom;
@@ -103,7 +103,7 @@ class AliHLTAltroGenerator : AliHLTLogging {
    * @param size        size of the header in byte
    * @return neg. error code if failed
    */
-  int SetCDH(AliRawDataHeader* pCDH, int size);
+  int SetCDH(AliRawDataHeaderV3* pCDH, int size);
 
   /**
    * Set the RCU trailer.
@@ -259,7 +259,7 @@ class AliHLTAltroGenerator : AliHLTLogging {
   int fNof10BitWords; //! transient
 
   /// the Common Data Header
-  AliRawDataHeader* fpCDH; //!transient
+  AliRawDataHeaderV3* fpCDH; //!transient
 
   /// size of the Common Data Header in byte
   int fCDHSize; //! transient
index 05fcce2..a8a6f08 100644 (file)
@@ -29,7 +29,7 @@
 #include "AliAltroRawStreamV3.h"
 #include "AliHLTAltroEncoder.h"
 #include "AliRawReaderMemory.h"
-#include "AliRawDataHeader.h"
+#include "AliHLTCDHWrapper.h"
 #include <memory>
 
 using namespace std;
@@ -217,8 +217,8 @@ int AliHLTAltroTimebinAverageComponent::DoEvent( const AliHLTComponentEventData&
     }
 
     altroEncoder->SetBuffer(outputPtr+offset,capacity-offset);
-    AliRawDataHeader cdh;
-    altroEncoder->SetCDH((AliHLTUInt8_t*)iter->fPtr,sizeof(AliRawDataHeader));
+    AliHLTCDHWrapper cdh(iter->fPtr);
+    altroEncoder->SetCDH((AliHLTUInt8_t*)iter->fPtr,cdh.GetHeaderSize());
 
     altroEncoder->SetRCUTrailer(RCUTrailer, RCUTrailerSize);
 
index 761d65c..ccd659e 100644 (file)
@@ -25,7 +25,7 @@
 #include "AliHLTErrorGuard.h"
 #include "AliHLTTPCHWCFEmulator.h"
 #include "AliHLTTPCTransform.h"
-#include "AliRawDataHeader.h"
+#include "AliHLTCDHWrapper.h"
 #include "TFile.h"
 #include <memory>
 #include <ostream>
@@ -305,8 +305,9 @@ int AliHLTTPCHWCFData::Open(const char* filename)
     iResult=-ENODATA;
   }
 
-  AliHLTUInt8_t* pBuffer=reinterpret_cast<AliHLTUInt8_t*>(buffer->GetArray()+sizeof(AliRawDataHeader));
-  unsigned bufferSize=buffer->GetSize()-sizeof(AliRawDataHeader);
+  AliHLTCDHWrapper header(buffer->GetArray());
+  AliHLTUInt8_t* pBuffer=reinterpret_cast<AliHLTUInt8_t*>(buffer->GetArray()+header.GetHeaderSize());
+  unsigned bufferSize=buffer->GetSize()-header.GetHeaderSize();
   if ((iResult=Init(pBuffer, bufferSize))<0 ||
       (iResult=CheckVersion())<0) {
     Reset();
index d9b6a99..1750d04 100755 (executable)
@@ -39,7 +39,7 @@
 #include "TString.h"
 #include <sys/time.h>
 #include "AliHLTAltroEncoder.h"
-#include "AliRawDataHeader.h"
+#include "AliHLTCDHWrapper.h"
 
 using namespace std;
 
@@ -263,7 +263,8 @@ int AliHLTTPCHWCFDataReverterComponent::DoEvent( const AliHLTComponentEventData&
       continue;
     }
 
-    if (iter->fSize<=sizeof(AliRawDataHeader)) {
+    AliHLTCDHWrapper header(iter->fPtr);
+    if (iter->fSize<=header.GetHeaderSize()) {
       // forward empty DDLs
       outputBlocks.push_back(*iter);
       continue;
@@ -318,7 +319,7 @@ int AliHLTTPCHWCFDataReverterComponent::DoEvent( const AliHLTComponentEventData&
       }
     }
 
-    if( iter->fSize > sizeof(AliRawDataHeader )){
+    if( iter->fSize > header.GetHeaderSize()){
   
       AliHLTAltroEncoder *altroEncoder = new AliHLTAltroEncoder;
       altroEncoder->SetUse32BitFormat(kTRUE);
@@ -332,7 +333,7 @@ int AliHLTTPCHWCFDataReverterComponent::DoEvent( const AliHLTComponentEventData&
       altroEncoder->SetBuffer(outputPtr,capacity); //tests if one overwrite the buffer is done in the encoder
 
       // set CDH from the beginning of buffer
-      altroEncoder->SetCDH((AliHLTUInt8_t*)iter->fPtr,sizeof(AliRawDataHeader));
+      altroEncoder->SetCDH((AliHLTUInt8_t*)iter->fPtr,header.GetHeaderSize());
 
       UChar_t *RCUTrailer=NULL;
       Int_t RCUTrailerSize=fDigitReader->GetRCUTrailerSize();
index 433b4b6..5e90b14 100644 (file)
@@ -33,7 +33,7 @@
 #include "AliHLTComponent.h"
 #include "AliHLTTemplates.h"
 #include "AliHLTDataDeflater.h"
-#include "AliRawDataHeader.h"
+#include "AliHLTCDHWrapper.h"
 #include "AliLog.h"
 #include "TMath.h"
 #include <memory>
@@ -111,7 +111,8 @@ int AliHLTTPCHWCFSpacePointContainer::AddInputBlock(const AliHLTComponentBlockDa
     return 0;
   }
   if (!pDesc->fPtr) return -ENODATA;
-  if (pDesc->fSize<=sizeof(AliRawDataHeader)) return 0;
+  AliHLTCDHWrapper header(pDesc->fPtr);
+  if (pDesc->fSize<=header.GetHeaderSize()) return 0;
 
   AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr( pDesc->fSpecification );
   AliHLTUInt8_t part  = AliHLTTPCDefinitions::GetMinPatchNr( pDesc->fSpecification );
@@ -119,9 +120,9 @@ int AliHLTTPCHWCFSpacePointContainer::AddInputBlock(const AliHLTComponentBlockDa
   AliHLTUInt32_t decoderIndex=AliHLTTPCSpacePointData::GetID(slice, part, 0);
 
   AliHLTUInt32_t *buffer=reinterpret_cast<AliHLTUInt32_t*>(pDesc->fPtr);
-  // skip the first 8 32-bit CDH words
-  buffer += 8;
-  UInt_t bufferSize32 = ((Int_t)pDesc->fSize - sizeof(AliRawDataHeader) )/sizeof(AliHLTUInt32_t);
+  // skip the first 8 or 10 CDH words
+  buffer += header.GetHeaderSize()/sizeof(AliHLTUInt32_t);
+  UInt_t bufferSize32 = ((Int_t)pDesc->fSize - header.GetHeaderSize() )/sizeof(AliHLTUInt32_t);
 
   AliHLTTPCHWCFData* pDecoder=NULL;
   AliHLTSpacePointPropertyGrid* pGrid=NULL;
index 4ffc7c5..b83afe7 100644 (file)
@@ -29,7 +29,7 @@
 #include "AliHLTTPCDefinitions.h"
 #include "AliHLTTPCSpacePointData.h"
 #include "AliHLTTPCClusterDataFormat.h"
-#include "AliRawDataHeader.h"
+#include "AliHLTCDHWrapper.h"
 #include "AliHLTTPCRawCluster.h"
 #include "AliHLTTPCHWCFEmulator.h"
 #include "AliHLTTPCHWCFData.h"
@@ -289,11 +289,12 @@ int AliHLTTPCHWClusterDecoderComponent::DoEvent(const AliHLTComponentEventData&
       outputRaw->fVersion = 0;
       outputRaw->fCount = 0;
       
-      AliHLTUInt32_t *buffer = (AliHLTUInt32_t*)iter->fPtr;  
+      AliHLTUInt32_t *buffer = (AliHLTUInt32_t*)iter->fPtr;
+      AliHLTCDHWrapper header(buffer);
      
       // skip the first 8 32-bit CDH words
-      buffer += 8;
-      UInt_t bufferSize32 = ((Int_t)iter->fSize - sizeof(AliRawDataHeader) )/sizeof(AliHLTUInt32_t);
+      buffer += header.GetHeaderSize()/sizeof(AliHLTUInt32_t);
+      UInt_t bufferSize32 = ((Int_t)iter->fSize - header.GetHeaderSize() )/sizeof(AliHLTUInt32_t);
       
       if (fpDecoder->Init(reinterpret_cast<AliHLTUInt8_t*>(buffer), bufferSize32*sizeof(AliHLTUInt32_t))>=0 && fpDecoder->CheckVersion()>=0) {
        
index 196246a..3282293 100644 (file)
@@ -27,7 +27,7 @@
 #include "AliHLTTPCTransform.h"
 #include "AliHLTTPCSpacePointData.h"
 #include "AliHLTTPCClusterDataFormat.h"
-#include "AliRawDataHeader.h"
+#include "AliHLTCDHWrapper.h"
 #include "AliHLTTPCRawCluster.h"
 #include "AliHLTTPCHWCFEmulator.h"
 #include "AliHLTTPCHWCFData.h"
@@ -254,11 +254,12 @@ int AliHLTTPCHWClusterTransformComponent::DoEvent(const AliHLTComponentEventData
     long maxPoints = ((long)maxOutSize-size-sizeof(AliHLTTPCClusterData))/sizeof(AliHLTTPCSpacePointData);
 
     AliHLTUInt32_t *buffer;     
-    buffer = (AliHLTUInt32_t*)iter->fPtr;  
+    buffer = (AliHLTUInt32_t*)iter->fPtr;
+    AliHLTCDHWrapper cdh(iter->fPtr);
      
      // skip the first 8 32-bit CDH words
-     buffer += 8;
-     UInt_t bufferSize32 = ((Int_t)iter->fSize - sizeof(AliRawDataHeader) )/sizeof(AliHLTUInt32_t);
+    buffer += cdh.GetHeaderSize()/sizeof(AliHLTUInt32_t);
+    UInt_t bufferSize32 = ((Int_t)iter->fSize - cdh.GetHeaderSize() )/sizeof(AliHLTUInt32_t);
 
      if (fpDecoder->Init(reinterpret_cast<AliHLTUInt8_t*>(buffer), bufferSize32*sizeof(AliHLTUInt32_t))>=0 && fpDecoder->CheckVersion()>=0) {
        for (AliHLTTPCHWCFData::iterator cl=fpDecoder->begin(); cl!=fpDecoder->end(); ++cl) {
index b241bc5..3183507 100644 (file)
@@ -30,7 +30,6 @@
 #include "AliHLTComponent.h"
 #include "AliHLTTemplates.h"
 #include "AliHLTDataDeflater.h"
-#include "AliRawDataHeader.h"
 #include "AliLog.h"
 #include "TMath.h"
 #include <memory>
index a9fbb8a..78326cc 100644 (file)
@@ -33,7 +33,7 @@
 #include "AliGRPObject.h"
 #include "AliCDBEntry.h"
 #include "AliCDBManager.h"
-#include "AliRawDataHeader.h"
+#include "AliHLTCDHWrapper.h"
 #include <cstdlib>
 #include <cerrno>
 #include "TString.h"
@@ -357,12 +357,14 @@ int AliHLTTPCHWCFConsistencyControlComponent::DoEvent( const AliHLTComponentEven
 
     int slice1 = AliHLTTPCDefinitions::GetMinSliceNr( *iter1 );
     int patch1 = AliHLTTPCDefinitions::GetMinPatchNr( *iter1 );
+
+    AliHLTCDHWrapper cdh1(iter1->fPtr);
    
     bool header1OK = 1;
     if( iter1->fSize>0 ){
       header1OK = ( iter1->fSize % sizeof(AliHLTUInt32_t) == 0 ) 
-       && ( iter1->fSize >= sizeof(AliRawDataHeader) ) 
-       && (iter1->fPtr != NULL );      
+       && (iter1->fPtr != NULL )
+       && ( iter1->fSize >= cdh1.GetHeaderSize() ) ;
     }
     
     int  nMatchedBlocks=0;
@@ -391,12 +393,14 @@ int AliHLTTPCHWCFConsistencyControlComponent::DoEvent( const AliHLTComponentEven
       checkedBlocks[ndx2] = 1;
 
       nMatchedBlocks++;
+      
+      AliHLTCDHWrapper cdh2(iter1->fPtr);
 
       bool header2OK = 1;
       if( iter2->fSize>0 ){
        header2OK = ( iter2->fSize % sizeof(AliHLTUInt32_t) == 0 ) 
-         && ( iter2->fSize >= sizeof(AliRawDataHeader) ) 
-         && (iter2->fPtr != NULL );
+         && (iter2->fPtr != NULL )
+         && ( iter2->fSize >= cdh2.GetHeaderSize() ) ;
       }
  
       fHistHeaderAll->Fill(2);
@@ -404,7 +408,7 @@ int AliHLTTPCHWCFConsistencyControlComponent::DoEvent( const AliHLTComponentEven
       if( sameHLTHd ) fHistHeaderGood->Fill(2);
       if( !header1OK || !header2OK ) continue;
       
-      int nWordsHeader =  sizeof(AliRawDataHeader)/sizeof(AliHLTUInt32_t);
+      int nWordsHeader =  cdh2.GetHeaderSize()/sizeof(AliHLTUInt32_t);
       int nWords1 = iter1->fSize/sizeof(AliHLTUInt32_t);
       int nWords2 = iter2->fSize/sizeof(AliHLTUInt32_t);
       const AliHLTUInt32_t *p1 = (const AliHLTUInt32_t *) iter1->fPtr;
index 933a670..8592df6 100644 (file)
@@ -35,7 +35,7 @@
 #include "AliGRPObject.h"
 #include "AliCDBEntry.h"
 #include "AliCDBManager.h"
-#include "AliRawDataHeader.h"
+#include "AliHLTCDHWrapper.h"
 #include <cstdlib>
 #include <cerrno>
 #include <memory>
@@ -488,13 +488,14 @@ int AliHLTTPCHWCFEmulatorComponent::DoEvent( const AliHLTComponentEventData& evt
        nMCLabels = 0;
       }
 
+      AliHLTCDHWrapper header(iter->fPtr);
       // book memory for the output
       
       AliHLTUInt32_t maxNClusters = rawEventSize32 + 1; // N 32-bit words in input
       AliHLTUInt32_t clustersSize32 = maxNClusters*AliHLTTPCHWCFData::fgkAliHLTTPCHWClusterSize;
       AliHLTUInt32_t nOutputMC = maxNClusters;
 
-      AliHLTUInt32_t headerSize = sizeof(AliRawDataHeader);
+      AliHLTUInt32_t headerSize = header.GetHeaderSize();
       AliHLTUInt32_t outBlockSize=headerSize+clustersSize32*sizeof(AliHLTUInt32_t);
 
       if( outBlock ) delete[] outBlock;
@@ -512,11 +513,13 @@ int AliHLTTPCHWCFEmulatorComponent::DoEvent( const AliHLTComponentEventData& evt
       AliHLTTPCClusterMCData *outMC = reinterpret_cast<AliHLTTPCClusterMCData *>(allocOutMC);
       
       // fill CDH header here, since the HW clusterfinder does not receive it
-      
-      AliRawDataHeader *cdhHeader = reinterpret_cast<AliRawDataHeader*>(iter->fPtr);
-      AliRawDataHeader *outCDHHeader = reinterpret_cast<AliRawDataHeader*>(outBlock);
-      *outCDHHeader = *cdhHeader;
-      outCDHHeader->fSize = 0xFFFFFFFF;
+      memcpy(outBlock, iter->fPtr, headerSize);
+      memset(outBlock,0xFF,4);
+
+      //AliRawDataHeader *cdhHeader = reinterpret_cast<AliRawDataHeader*>(iter->fPtr);
+      //AliRawDataHeader *outCDHHeader = reinterpret_cast<AliRawDataHeader*>(outBlock);
+      //*outCDHHeader = *cdhHeader;
+      //outCDHHeader->fSize = 0xFFFFFFFF;
 
       AliHLTUInt32_t *outClusters = reinterpret_cast<AliHLTUInt32_t*> (outBlock + headerSize);
      
index f913076..7264d1e 100644 (file)
@@ -31,7 +31,7 @@
 #include "AliHLTTPCDigitReaderUnpacked.h"
 #include "AliHLTTPCTransform.h"
 #include "AliHLTTPCDefinitions.h"
-#include "AliRawDataHeader.h"
+#include "AliHLTCDHWrapper.h"
 #include "AliHLTTPCHWCFEmulator.h"
 #include "AliTPCcalibDB.h"
 #include "AliTPCCalPad.h"
@@ -340,15 +340,14 @@ int AliHLTTPCHWCFSupport::CreateRawEvent
       // already raw format -> only set the pointers and estimate the size
 
       // read CDH header, estimate size of the data 
-      
-      AliHLTUInt64_t headerSize = sizeof(AliRawDataHeader);                  
+      AliHLTCDHWrapper cdhHeader(block->fPtr);
+
+      AliHLTUInt64_t headerSize = cdhHeader.GetHeaderSize();
  
-      AliRawDataHeader *cdhHeader = reinterpret_cast<AliRawDataHeader*>(block->fPtr);
-      
       AliHLTUInt64_t blockSize = block->fSize; // size of the raw data in bytes      
 
-      if( cdhHeader->fSize!=0xFFFFFFFF ){ // use size information from the header
-       blockSize = cdhHeader->fSize;
+      if( cdhHeader.GetDataSize()!=0xFFFFFFFF ){ // use size information from the header
+       blockSize = cdhHeader.GetDataSize();
        if( blockSize > block->fSize ){
          HLTWarning("%s Could not find a valid DDL header!",str);
          return 0;
@@ -556,10 +555,12 @@ int AliHLTTPCHWCFSupport::CheckRawData( const AliHLTUInt32_t *buffer,
   // The procedure checks consistency of the data
   //
 
-  const unsigned int headerSize32 = 8;
 
   if (!buffer) return 0;
 
+  AliHLTCDHWrapper cdh((void*)buffer);
+  const unsigned int headerSize32 = cdh.GetHeaderSize()/4;
+
   const char *str=Form("slice %d patch %d:", slice, patch);
   
   if( bufferSize32 < headerSize32 ){
index e5f23f1..a8f38c0 100644 (file)
@@ -33,7 +33,6 @@
 
 #include "AliHLTTPCCalibCEComponent.h"
 
-//#include "AliRawDataHeader.h"
 #include "AliRawReaderMemory.h"
 #include "AliTPCRawStream.h"
 
index e742309..7dc1119 100755 (executable)
@@ -31,7 +31,6 @@
 
 #include "AliHLTTPCCalibPedestalComponent.h"
 
-#include "AliRawDataHeader.h"
 #include "AliRawReaderMemory.h"
 #include "AliTPCRawStream.h"
 
index a926dd0..00e46b1 100644 (file)
@@ -31,7 +31,6 @@
 
 #include "AliHLTTPCCalibPulserComponent.h"
 
-#include "AliRawDataHeader.h"
 #include "AliRawReaderMemory.h"
 #include "AliTPCRawStream.h"
 
index 6463134..5a0a897 100644 (file)
@@ -36,7 +36,6 @@
 #include "AliHLTTPCClusterMCData.h"
 #include "AliHLTTPCClusterTransformation.h"
 #include "AliHLTErrorGuard.h"
-#include "AliRawDataHeader.h"
 #include "AliCDBManager.h"
 #include "AliCDBPath.h"
 #include "AliCDBId.h"
index d60c380..940d2d3 100644 (file)
@@ -25,7 +25,6 @@
 #include "AliHLTTPCSpacePointData.h"
 #include "AliHLTTPCRawCluster.h"
 #include "AliHLTComponent.h"
-#include "AliRawDataHeader.h"
 
 #include <vector>
 #include <algorithm>
index 22fdc90..d18cff7 100644 (file)
@@ -34,7 +34,7 @@
 #include "AliHLTTPCHWCFSpacePointContainer.h"
 #include "AliHLTErrorGuard.h"
 #include "AliHLTComponentBenchmark.h"
-#include "AliRawDataHeader.h"
+#include "AliHLTCDHWrapper.h"
 #include "AliTPCclusterMI.h"
 #include "AliTPCROC.h"
 #include "TH1I.h"
@@ -165,13 +165,14 @@ int AliHLTTPCDataCompressionMonitorComponent::DoEvent( const AliHLTComponentEven
        pDesc!=NULL; pDesc=GetNextInputBlock()) {
     fFlags|=kHaveHWClusters;
     // FIXME: the decoding can now be handled via the data container
-    if (pDesc->fSize<=sizeof(AliRawDataHeader)) continue;
+    AliHLTCDHWrapper header(pDesc->fPtr);
+    if (pDesc->fSize<=header.GetHeaderSize()) continue;
     if (fpHWClusterDecoder) {
       hwclustersDataSize+=pDesc->fSize;
       AliHLTUInt8_t* pData=reinterpret_cast<AliHLTUInt8_t*>(pDesc->fPtr);
-      pData+=sizeof(AliRawDataHeader);
-      if (fpHWClusterDecoder->Init(pData, pDesc->fSize-sizeof(AliRawDataHeader))<0 ||
-         (fpHWClusterDecoder->CheckVersion()<0 && (int)(pDesc->fSize-sizeof(AliRawDataHeader))>fpHWClusterDecoder->GetRCUTrailerSize())) {
+      pData+=header.GetHeaderSize();
+      if (fpHWClusterDecoder->Init(pData, pDesc->fSize-header.GetHeaderSize())<0 ||
+         (fpHWClusterDecoder->CheckVersion()<0 && (int)(pDesc->fSize-header.GetHeaderSize())>fpHWClusterDecoder->GetRCUTrailerSize())) {
        HLTError("data block of type %s corrupted: can not decode format",
                 AliHLTComponent::DataType2Text(pDesc->fDataType).c_str());
       } else {
@@ -180,7 +181,7 @@ int AliHLTTPCDataCompressionMonitorComponent::DoEvent( const AliHLTComponentEven
          // first word of the RCU trailer contains the payload size in 32bit words
          const AliHLTUInt32_t*  pRCUTrailer=reinterpret_cast<const AliHLTUInt32_t*>(fpHWClusterDecoder->GetRCUTrailer());
          AliHLTUInt32_t payloadSize=(*pRCUTrailer)&0x00ffffff;
-         rawEventSizeFromRCUtrailer+=sizeof(AliRawDataHeader)
+         rawEventSizeFromRCUtrailer+=header.GetHeaderSize()
            + payloadSize*sizeof(AliHLTUInt32_t)
            + fpHWClusterDecoder->GetRCUTrailerSize();
        }
index 2cda6af..1f41116 100644 (file)
@@ -163,12 +163,19 @@ int AliHLTTRDEsdWriterComponent::DumpEvent( const AliHLTComponentEventData& /*ev
 
   const AliHLTCTPData* pCTPData=CTPData();
   if (pCTPData) {
-    AliHLTUInt64_t mask=pCTPData->ActiveTriggers(trigData);
+    AliHLTTriggerMask_t mask=pCTPData->ActiveTriggers(trigData);
     for (int index=0; index<gkNCTPTriggerClasses; index++) {
-      if ((mask&((AliHLTUInt64_t)0x1<<index)) == 0) continue;
+      if ((mask&(AliHLTTriggerMask_t(0x1)<<index)) == 0) continue;
       fESD->SetTriggerClass(pCTPData->Name(index), index);
     }
-    fESD->SetTriggerMask(mask);
+    //first 50 triggers
+    AliHLTTriggerMask_t mask50;
+    mask50.set(); // set all bits
+    mask50 >>= 50; // shift 50 right
+    fESD->SetTriggerMask((mask&mask50).to_ulong());
+    /* next 50, to be implemented 
+    pESD->SetTriggerMaskNext50((mask>>50).to_ulong());
+    */
   }
   
   for(int i=0; i<usedEntries; i++){
index b3b318b..3e5e15f 100644 (file)
@@ -313,12 +313,19 @@ int AliHLTGlobalEsdConverterComponent::DoEvent(const AliHLTComponentEventData& /
 
   const AliHLTCTPData* pCTPData=CTPData();
   if (pCTPData) {
-    AliHLTUInt64_t mask=pCTPData->ActiveTriggers(trigData);
+    AliHLTTriggerMask_t mask=pCTPData->ActiveTriggers(trigData);
     for (int index=0; index<gkNCTPTriggerClasses; index++) {
-      if ((mask&((AliHLTUInt64_t)0x1<<index)) == 0) continue;
+      if ((mask&(AliHLTTriggerMask_t(0x1)<<index)) == 0) continue;
       pESD->SetTriggerClass(pCTPData->Name(index), index);
     }
-    pESD->SetTriggerMask(mask);
+    //first 50 triggers
+    AliHLTTriggerMask_t mask50;
+    mask50.set(); // set all bits
+    mask50 >>= 50; // shift 50 right
+    pESD->SetTriggerMask((mask&mask50).to_ulong());
+    /* next 50, to be implemented 
+    pESD->SetTriggerMaskNext50((mask>>50).to_ulong());
+    */
   }
 
   TTree* pTree = NULL;
index d1ff06c..dc90047 100644 (file)
@@ -217,14 +217,20 @@ int AliHLTMiscImplementation::InitMagneticField() const
   return -ENOENT;
 }
 
-AliHLTUInt64_t AliHLTMiscImplementation::GetTriggerMask(AliRawReader* rawReader) const
+AliHLTTriggerMask_t AliHLTMiscImplementation::GetTriggerMask(AliRawReader* rawReader) const
 {
   // see header file for function documentation
   if (!rawReader) return 0;
-  AliHLTUInt64_t trgMask=0;
+  AliHLTTriggerMask_t trgMask=0;
   if (rawReader) {
     const UInt_t* pattern=rawReader->GetTriggerPattern();
-    trgMask=pattern[1]&0xfffffff; // 28 upper bits of the 50 bit mask
+    if(rawReader->GetVersion()==3){
+      trgMask=pattern[3];
+      trgMask<<=32;
+      trgMask|=pattern[2];
+      trgMask<<=32;
+    }
+    trgMask|=pattern[1];
     trgMask<<=32;
     trgMask|=pattern[0]; // 32 lower bits of the mask
   }
index bb00901..31caa49 100644 (file)
@@ -36,7 +36,7 @@ class AliHLTMiscImplementation : public AliHLTMisc
 
   int InitMagneticField() const;
 
-  AliHLTUInt64_t GetTriggerMask(AliRawReader* rawReader) const;
+  AliHLTTriggerMask_t GetTriggerMask(AliRawReader* rawReader) const;
 
   AliHLTUInt32_t GetTimeStamp(AliRawReader* rawReader) const;
   AliHLTUInt32_t GetEventType(AliRawReader* rawReader) const;
index 3c4e93e..05e8633 100644 (file)
@@ -22,7 +22,7 @@
 ///
 
 #include "AliHLTOUTDigitReader.h"
-#include "AliRawDataHeader.h"
+#include "AliHLTCDHWrapper.h"
 #include "AliDAQ.h"
 #include "TTree.h"
 #include "TFile.h"
@@ -78,9 +78,11 @@ Bool_t AliHLTOUTDigitReader::ReadNextData(UChar_t*& data)
   while (++fCurrentLink<fNofDDLs) {
     if (fMinDDL>-1 && fMinDDL>fpEquipments[fCurrentLink]) continue;
     if (fMaxDDL>-1 && fMaxDDL<fpEquipments[fCurrentLink]) continue;
-    if (fppDigitArrays[fCurrentLink]->GetSize()>(int)sizeof(AliRawDataHeader)) {
+    AliHLTCDHWrapper cdh((void*)fppDigitArrays[fCurrentLink]->GetArray());
+    UInt_t headerSize=cdh.GetHeaderSize();
+    if (fppDigitArrays[fCurrentLink]->GetSize()>(int)headerSize) {
       data=reinterpret_cast<UChar_t*>(fppDigitArrays[fCurrentLink]->GetArray());
-      data+=sizeof(AliRawDataHeader);
+      data+=headerSize;
       return kTRUE;
     }
   }
@@ -98,16 +100,17 @@ int AliHLTOUTDigitReader::GetDataSize()
 {
   // overloaded from AliHLTOUTHomerCollection: get size of current DDL
   if (fCurrentLink>=0 && fCurrentLink<fNofDDLs && fppDigitArrays) {
-    return fppDigitArrays[fCurrentLink]->GetSize()-sizeof(AliRawDataHeader);
+    AliHLTCDHWrapper cdh((void*)fppDigitArrays[fCurrentLink]->GetArray());
+    return fppDigitArrays[fCurrentLink]->GetSize()-cdh.GetHeaderSize();
   }
   return 0;
 }
 
-const AliRawDataHeader* AliHLTOUTDigitReader::GetDataHeader()
+AliHLTCDHWrapper AliHLTOUTDigitReader::GetDataHeader()
 {
   // overloaded from AliHLTOUTHomerCollection: get data header of current DDL
   if (fCurrentLink>=0 && fCurrentLink<fNofDDLs && fppDigitArrays) {
-    return reinterpret_cast<AliRawDataHeader*>(fppDigitArrays[fCurrentLink]->GetArray());
+    return AliHLTCDHWrapper(fppDigitArrays[fCurrentLink]->GetArray());
   }
   return NULL;
 }
index 49d3a27..31d7046 100644 (file)
@@ -38,7 +38,7 @@ class AliHLTOUTDigitReader : public AliHLTOUTHomerCollection {
   Bool_t ReadNextData(UChar_t*& data);
   int Reset();
   int GetDataSize();
-  const AliRawDataHeader* GetDataHeader();
+  AliHLTCDHWrapper GetDataHeader();
   void SelectEquipment(int equipmentType, int minEquipmentId = -1, int maxEquipmentId = -1);
   int GetEquipmentId();
 
index c7f2ca1..c75afb5 100644 (file)
@@ -24,7 +24,6 @@
 #include "AliHLTOUTHomerCollection.h"
 #include "AliHLTHOMERLibManager.h"
 #include "AliHLTHOMERReader.h"
-#include "AliRawDataHeader.h"
 #include "AliHLTEsdManager.h"
 #include "AliDAQ.h"
 
@@ -139,9 +138,9 @@ AliHLTHOMERReader* AliHLTOUTHomerCollection::OpenReader(UChar_t* pSrc, unsigned
 {
   // open HOMER reader for buffer
   unsigned int offset=sizeof(AliHLTOUTEventHeader);
-  const AliRawDataHeader* pCDH=GetDataHeader();
+  AliHLTCDHWrapper pCDH=GetDataHeader();
   AliHLTUInt32_t id=(GetEquipmentId());
-  AliHLTUInt32_t statusFlags=pCDH->GetStatus();
+  AliHLTUInt32_t statusFlags=pCDH.GetStatus();
   AliHLTOUTEventHeader* pHLTHeader=reinterpret_cast<AliHLTOUTEventHeader*>(pSrc);
 
   // consistency check for the block size
index c65c653..a81efaa 100644 (file)
@@ -13,9 +13,9 @@
 /// @brief  General collection for HLTOUT data in DDL format.
 ///
 #include "AliHLTOUTHomerBuffer.h"
+#include "AliHLTCDHWrapper.h"
 
 class AliHLTHOMERReader;
-class AliRawDataHeader;
 class AliHLTEsdManager;
 
 /**
@@ -58,7 +58,7 @@ class AliHLTOUTHomerCollection : public AliHLTOUTHomerBuffer {
   /**
    * Get the header of the current data block
    */
-  virtual const AliRawDataHeader* GetDataHeader()=0;
+  virtual AliHLTCDHWrapper GetDataHeader()=0;
 
   /**
    * Select equipment for data readout.
index db510e2..8a50e33 100644 (file)
@@ -77,7 +77,7 @@ int AliHLTOUTRawReader::GetDataSize()
   return 0;
 }
 
-const AliRawDataHeader* AliHLTOUTRawReader::GetDataHeader()
+AliHLTCDHWrapper AliHLTOUTRawReader::GetDataHeader()
 {
   // overloaded from AliHLTOUTHomerCollection: get data header of current DDL
   if (fpRawreader) return fpRawreader->GetDataHeader();
index e2db4e9..b7cc765 100644 (file)
@@ -36,7 +36,7 @@ class AliHLTOUTRawReader : public AliHLTOUTHomerCollection {
   Bool_t ReadNextData(UChar_t*& data);
   int Reset();
   int GetDataSize();
-  const AliRawDataHeader* GetDataHeader();
+  AliHLTCDHWrapper GetDataHeader();
   void SelectEquipment(int equipmentType, int minEquipmentId = -1, int maxEquipmentId = -1);
   int GetEquipmentId();
 
index 9746619..5982f97 100644 (file)
@@ -29,6 +29,7 @@
 #include "AliHLTOUTHandlerEquId.h"
 #include "AliHLTSystem.h"
 #include "AliHLTPluginBase.h"
+#include "AliHLTCDHWrapper.h"
 #include "AliLog.h"
 #include "AliDAQ.h"            // RAW, for detector names and equipment ids
 #include "TObjString.h"
@@ -163,7 +164,7 @@ Int_t    AliRawReaderHLT::GetEquipmentSize() const
   // fDataSize has been set to the full size of the block if it is from HLTOUT
   // if the data block is from the parent rawreader it is only the pointer
   // to the payload and the size of the CDH must be added
-  if (fEquipmentId>=0) return fDataSize + (fbHaveHLTData?0:sizeof(AliRawDataHeader));
+  if (fEquipmentId>=0) return fDataSize + (fbHaveHLTData?0:GetEquipmentHeaderSize());
   return fpParentReader->GetEquipmentSize();
 }
 
@@ -192,8 +193,15 @@ Bool_t   AliRawReaderHLT::ReadHeader()
   while ((fbHaveHLTData=(fbHaveHLTData && ReadNextHLTData()))) {
     // all internal data variables set
     assert(fpData!=NULL);
-    fHeader=reinterpret_cast<AliRawDataHeader*>(const_cast<AliHLTUInt8_t*>(fpData));
-    fOffset=sizeof(AliRawDataHeader);
+    AliHLTCDHWrapper cdh((void*)fpData);
+    if(cdh.GetVersion()==2){
+      fHeader=reinterpret_cast<AliRawDataHeader*>(const_cast<AliHLTUInt8_t*>(fpData));
+      fHeaderV3=NULL;
+    } else {
+      fHeader=NULL;
+      fHeaderV3=reinterpret_cast<AliRawDataHeaderV3*>(const_cast<AliHLTUInt8_t*>(fpData));
+    }
+    fOffset=cdh.GetHeaderSize();
     fPosition=fOffset;
     if ((result=IsSelected())) break;
   }
@@ -208,9 +216,11 @@ Bool_t   AliRawReaderHLT::ReadHeader()
 
     if (!(result=fpParentReader->ReadHeader())) {
       fHeader=NULL;
+      fHeaderV3=NULL;
       break;
     }
     fHeader=const_cast<AliRawDataHeader*>(fpParentReader->GetDataHeader());
+    fHeaderV3=const_cast<AliRawDataHeaderV3*>(fpParentReader->GetDataHeaderV3());
     fDataSize=fpParentReader->GetDataSize();
     fPosition=0;
     fpData=NULL;
@@ -241,9 +251,10 @@ Bool_t   AliRawReaderHLT::ReadNextData(UChar_t*& data, Bool_t readHeader)
     if (fbHaveHLTData && fpHLTOUT!=NULL) {
       // all internal data variables set
       result=kTRUE;
-      data=const_cast<AliHLTUInt8_t*>(fpData+sizeof(AliRawDataHeader));
+      AliHLTCDHWrapper cdh((void*) fpData);
+      data=const_cast<AliHLTUInt8_t*>(fpData+cdh.GetHeaderSize());
       // fpData includes the CDH, set offset behind CDH
-      fOffset=sizeof(AliRawDataHeader);
+      fOffset=cdh.GetHeaderSize();
     } else {
       // no data in the HLT stream, read real data
       //AliInfo(Form("read from parent reader: min=%d max=%d", fSelectMinEquipmentId, fSelectMaxEquipmentId));
index af2feb1..71eb1fb 100644 (file)
@@ -30,7 +30,7 @@
 #include "AliHLTHOMERWriter.h"
 #include "AliHLTErrorGuard.h"
 #include "AliDAQ.h" // equipment Ids
-#include "AliRawDataHeader.h" // Common Data Header 
+#include "AliRawDataHeaderV3.h" // Common Data Header 
 #include <TDatime.h> // seed for TRandom
 #include <TRandom.h> // random int generation for DDL no
 #include <TFile.h>
@@ -492,8 +492,7 @@ int AliHLTOUTComponent::FillOutputBuffer(int eventNo, AliHLTMonitoringWriter* pW
   unsigned int bufferSize=0;
 
   // space for common data header
-  bufferSize+=sizeof(AliRawDataHeader);
-  assert(sizeof(AliRawDataHeader)==32);
+  bufferSize+=sizeof(AliRawDataHeaderV3);
 
   // space for HLT event header
   bufferSize+=sizeof(AliHLTOUT::AliHLTOUTEventHeader);
@@ -512,14 +511,14 @@ int AliHLTOUTComponent::FillOutputBuffer(int eventNo, AliHLTMonitoringWriter* pW
   memset(&fBuffer[bufferSize-4], 0, 4);
 
   if (bufferSize<=fBuffer.size()) {
-    AliRawDataHeader* pCDH=reinterpret_cast<AliRawDataHeader*>(&fBuffer[0]);
-    AliHLTOUT::AliHLTOUTEventHeader* pHLTH=reinterpret_cast<AliHLTOUT::AliHLTOUTEventHeader*>(&fBuffer[sizeof(AliRawDataHeader)]);
-    *pCDH = AliRawDataHeader();  // Fill with default values.
+    AliRawDataHeaderV3* pCDH=reinterpret_cast<AliRawDataHeaderV3*>(&fBuffer[0]);
+    AliHLTOUT::AliHLTOUTEventHeader* pHLTH=reinterpret_cast<AliHLTOUT::AliHLTOUTEventHeader*>(&fBuffer[sizeof(AliRawDataHeaderV3)]);
+    *pCDH = AliRawDataHeaderV3();  // Fill with default values.
     memset(pHLTH, 0, sizeof(AliHLTOUT::AliHLTOUTEventHeader));
 
     if (pWriter) {
       // copy payload
-      pWriter->Copy(&fBuffer[sizeof(AliRawDataHeader)+sizeof(AliHLTOUT::AliHLTOUTEventHeader)], 0, 0, 0, 0);
+      pWriter->Copy(&fBuffer[sizeof(AliRawDataHeaderV3)+sizeof(AliHLTOUT::AliHLTOUTEventHeader)], 0, 0, 0, 0);
       pHLTH->fLength=pWriter->GetTotalMemorySize();
       // set status bit to indicate HLT payload
       pCDH->fStatusMiniEventID|=0x1<<(AliHLTOUT::kCDHStatusFlagsOffset+AliHLTOUT::kCDHFlagsHLTPayload);
index 1343caf..d26055c 100644 (file)
@@ -32,7 +32,6 @@
 #include "AliCDBManager.h"
 #include "AliCDBStorage.h"
 #include "AliCDBEntry.h"
-#include "AliRawDataHeader.h"
 #include "TUUID.h"
 #include "TROOT.h"
 #include "TSystem.h"
@@ -502,8 +501,11 @@ int AliHLTGlobalTriggerComponent::DoTrigger()
   }
   
   fCDH = NULL;  // have to reset this in case ExtractTriggerData fails.
-  ExtractTriggerData(*GetTriggerData(), NULL, NULL, &fCDH, NULL);
-
+  int triggerSuccess=ExtractTriggerData(*GetTriggerData(), NULL, NULL, &fCDH, NULL, true);
+  if(triggerSuccess<0){
+    HLTError("Couldn't extract CDH from trigger data: %s", strerror(-triggerSuccess));
+    return -EPROTO;
+  }
   // Copy the trigger counters in case we need to set them back to their original
   // value because the PushBack method fails with ENOSPC.
   TArrayL64 originalCounters = fTrigger->GetCounters();
@@ -657,8 +659,7 @@ int AliHLTGlobalTriggerComponent::DoTrigger()
   }
   else if (softwareTriggerIsValid)
   {
-    assert(fCDH != NULL);
-    UInt_t detectors = fCDH->GetSubDetectors();
+    UInt_t detectors = fCDH.GetSubDetectors();
     readoutMask = AliHLTReadoutList(Int_t(detectors | AliHLTReadoutList::kHLT));
   }
   readoutlist.AndEq(readoutMask);
@@ -1859,8 +1860,7 @@ bool AliHLTGlobalTriggerComponent::FillSoftwareTrigger()
 {
   // Fills the fSoftwareTrigger structure.
   
-  if (fCDH == NULL) return false;
-  UChar_t l1msg = fCDH->GetL1TriggerMessage();
+  UChar_t l1msg = fCDH.GetL1TriggerMessage();
   if ((l1msg & 0x1) == 0x0) return false;  // skip physics events.
   // From here on everything must be a software trigger.
   if (((l1msg >> 2) & 0xF) == 0xE)
@@ -1883,7 +1883,7 @@ bool AliHLTGlobalTriggerComponent::FillSoftwareTrigger()
     fSoftwareTrigger.Name("SOFTWARE");
     fSoftwareTrigger.Description("Generated internal software trigger.");
   }
-  UInt_t detectors = fCDH->GetSubDetectors();
+  UInt_t detectors = fCDH.GetSubDetectors();
   fSoftwareTrigger.ReadoutList( AliHLTReadoutList(Int_t(detectors)) );
   return true;
 }
@@ -1909,8 +1909,8 @@ int AliHLTGlobalTriggerComponent::AddCTPDecisions(AliHLTGlobalTrigger* pTrigger,
   // add trigger decisions for the valid CTP classes
   if (!pCTPData || !pTrigger) return 0;
 
-  AliHLTUInt64_t triggerMask=pCTPData->Mask();
-  AliHLTUInt64_t bit0=0x1;
+  AliHLTTriggerMask_t triggerMask=pCTPData->Mask();
+  AliHLTTriggerMask_t bit0(0x1);
   if (!fCTPDecisions) {
     try
     {
@@ -1934,7 +1934,7 @@ int AliHLTGlobalTriggerComponent::AddCTPDecisions(AliHLTGlobalTrigger* pTrigger,
     }
     for (int i=0; i<gkNCTPTriggerClasses; i++) {
       const char* name=pCTPData->Name(i);
-      if (triggerMask&(bit0<<i) && name) {
+      if ( (triggerMask&(bit0<<i)).any() && name) {
        AliHLTTriggerDecision* pDecision=dynamic_cast<AliHLTTriggerDecision*>(fCTPDecisions->At(i));
        assert(pDecision);
        if (!pDecision) {
@@ -1949,7 +1949,7 @@ int AliHLTGlobalTriggerComponent::AddCTPDecisions(AliHLTGlobalTrigger* pTrigger,
 
   for (int i=0; i<gkNCTPTriggerClasses; i++) {
     const char* name=pCTPData->Name(i);
-    if ((triggerMask&(bit0<<i))==0 || name==NULL) continue;
+    if ((triggerMask&(bit0<<i)).none() || name==NULL) continue;
     AliHLTTriggerDecision* pDecision=dynamic_cast<AliHLTTriggerDecision*>(fCTPDecisions->At(i));
     HLTDebug("updating CTP trigger decision %d %s (%p casted %p)", i, name, fCTPDecisions->At(i), pDecision);
     if (!pDecision) return -ENOENT;
@@ -1957,10 +1957,10 @@ int AliHLTGlobalTriggerComponent::AddCTPDecisions(AliHLTGlobalTrigger* pTrigger,
     bool result=false;
     // 13 March 2010 - Optimisation:
     // Dont use the EvaluateCTPTriggerClass method, which uses slow TFormula objects.
-    AliHLTUInt64_t triggers = 0;
+    AliHLTTriggerMask_t triggers = 0;
     if (trigData) triggers = pCTPData->ActiveTriggers(*trigData);
     else triggers = pCTPData->Triggers();
-    result = (triggers&((AliHLTUInt64_t)0x1<<i)) ? true : false;
+    result = (triggers&(bit0<<i)).any() ? true : false;
     //if (trigData) result=pCTPData->EvaluateCTPTriggerClass(name, *trigData);
     //else result=pCTPData->EvaluateCTPTriggerClass(name);
     pDecision->Result(result);
index 1df5f36..a4a138a 100644 (file)
 #include "AliHLTTrigger.h"
 #include "AliHLTTriggerDecision.h"
 #include "TClonesArray.h"
+#include "AliHLTCDHWrapper.h"
 
 class AliHLTTriggerMenu;
 class AliHLTGlobalTrigger;
-class AliRawDataHeader;
 
 /**
  * \class AliHLTGlobalTriggerComponent
@@ -336,7 +336,7 @@ class AliHLTGlobalTriggerComponent : public AliHLTTrigger
   UInt_t fUniqueID; //! Unique ID for the decision output objects.
   AliHLTTriggerDecision fSoftwareTrigger; //! Software or calibration trigger decision object to be added to trigger logic.
   AliHLTUInt64_t fTotalEventCounter; //! Counts the total number of events handled.
-  const AliRawDataHeader* fCDH; //! The extracted CDH from the trigger data passed by the framework.
+  AliHLTCDHWrapper fCDH; //! The extracted CDH from the trigger data passed by the framework.
 
   static const char* fgkTriggerMenuCDBPath; //! The path string to read the trigger menu from the CDB.