Major update required to handle old and new AliHLTEventDDL structures within HLT...
authoraszostak <aszostak@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 25 Jun 2010 01:40:32 +0000 (01:40 +0000)
committeraszostak <aszostak@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 25 Jun 2010 01:40:32 +0000 (01:40 +0000)
Removed some deprecated methods from AliHLTComponent which are better placed inside AliHLTReadoutList.
Cleaned up and centralised manipulation of DDL readout list bits. Now AliHLTReadoutList is the common interface to use.

23 files changed:
HLT/BASE/AliHLTCTPData.cxx
HLT/BASE/AliHLTCTPData.h
HLT/BASE/AliHLTCalibrationProcessor.cxx
HLT/BASE/AliHLTCalibrationProcessor.h
HLT/BASE/AliHLTComponent.cxx
HLT/BASE/AliHLTComponent.h
HLT/BASE/AliHLTReadoutList.cxx
HLT/BASE/AliHLTReadoutList.h
HLT/BASE/test/testAliHLTReadoutList.C
HLT/BASE/util/AliHLTReadoutListDumpComponent.cxx
HLT/BASE/util/AliHLTReadoutListDumpComponent.h
HLT/SampleLib/AliHLTSampleCalibrationComponent.cxx
HLT/TPCLib/calibration/AliHLTTPCCalibTimeComponent.cxx
HLT/TPCLib/calibration/AliHLTTPCCalibTimeGainComponent.cxx
HLT/TPCLib/calibration/AliHLTTPCCalibrationComponent.cxx
HLT/TPCLib/offline/AliHLTTPCOfflineCalibrationComponent.cxx
HLT/TRD/AliHLTTRDCalibFitComponent.cxx
HLT/TRD/AliHLTTRDCalibrationComponent.cxx
HLT/comp/AliHLTCOMPHuffmanAltroCalibComponent.cxx
HLT/trigger/AliHLTEventSummaryProducerComponent.cxx
HLT/trigger/AliHLTRunSummaryProducerComponent.cxx
HLT/trigger/AliHLTTrigger.cxx
HLT/trigger/AliHLTTrigger.h

index 7f73f75..733b073 100644 (file)
 //  @note
 
 #include "AliHLTCTPData.h"
-#include "AliHLTReadoutList.h"
 #include "TClass.h"
 #include "TObjString.h"
 #include "TFormula.h"
+#include "AliHLTComponent.h"
+#include "AliRawDataHeader.h"
 
 /** ROOT macro for the implementation of ROOT specific class methods */
 ClassImp(AliHLTCTPData)
@@ -229,32 +230,25 @@ int AliHLTCTPData::InitCTPTriggerClasses(const char* ctpString)
 AliHLTUInt64_t AliHLTCTPData::ActiveTriggers(const AliHLTComponentTriggerData& trigData)
 {
   // extract active triggers from the trigger data
-  if (trigData.fDataSize != sizeof(AliHLTEventTriggerData)) return (AliHLTUInt64_t)0;
 
+  const AliRawDataHeader* cdh = NULL;
+  if (AliHLTComponent::ExtractTriggerData(trigData, NULL, NULL, &cdh, NULL) != 0) return (AliHLTUInt64_t)0;
   // trigger mask is 50 bit wide and is stored in word 5 and 6 of the CDH
-  AliHLTEventTriggerData* evtData=reinterpret_cast<AliHLTEventTriggerData*>(trigData.fData);
-  AliHLTUInt64_t triggerMask=evtData->fCommonHeader[6]&0x3ffff;
-  triggerMask<<=32;
-  triggerMask|=evtData->fCommonHeader[5];
+  AliHLTUInt64_t triggerMask = cdh->GetTriggerClasses();
   return triggerMask;
 }
 
 bool AliHLTCTPData::EvaluateCTPTriggerClass(const char* expression, const AliHLTComponentTriggerData& trigData) const
 {
   // see header file for function documentation
-  if (trigData.fDataSize != sizeof(AliHLTEventTriggerData)) {
-    HLTError("invalid trigger data size: %d expected %d", trigData.fDataSize, sizeof(AliHLTEventTriggerData));
-    return false;
-  }
-
+  
+  const AliRawDataHeader* cdh = NULL;
+  if (AliHLTComponent::ExtractTriggerData(trigData, NULL, NULL, &cdh, NULL, true) != 0) return false;
   // trigger mask is 50 bit wide and is stored in word 5 and 6 of the CDH
-  AliHLTEventTriggerData* evtData=reinterpret_cast<AliHLTEventTriggerData*>(trigData.fData);
-  AliHLTUInt64_t triggerMask=evtData->fCommonHeader[6]&0x3ffff;
-  triggerMask<<=32;
-  triggerMask|=evtData->fCommonHeader[5];
+  AliHLTUInt64_t triggerMask = cdh->GetTriggerClasses();
 
   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]);
     return false;
@@ -364,18 +358,14 @@ void AliHLTCTPData::Increment(int classIdx)
 int AliHLTCTPData::Increment(AliHLTComponentTriggerData& trigData)
 {
   // see header file for function documentation
-  if (trigData.fDataSize != sizeof(AliHLTEventTriggerData)) {
-    HLTError("invalid trigger data size: %d expected %d", trigData.fDataSize, sizeof(AliHLTEventTriggerData));
-    return -EBADF;
-  }
-
+  const AliRawDataHeader* cdh = NULL;
+  int result = AliHLTComponent::ExtractTriggerData(trigData, NULL, NULL, &cdh, NULL, true);
+  if (result != 0) return result;
   // trigger mask is 50 bit wide and is stored in word 5 and 6 of the CDH
-  AliHLTEventTriggerData* evtData=reinterpret_cast<AliHLTEventTriggerData*>(trigData.fData);
-  AliHLTUInt64_t triggerMask=evtData->fCommonHeader[6]&0x3ffff;
-  triggerMask<<=32;
-  triggerMask|=evtData->fCommonHeader[5];
+  AliHLTUInt64_t triggerMask = cdh->GetTriggerClasses();
 
   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]);
   }
@@ -429,23 +419,17 @@ int AliHLTCTPData::ReadMap(vector<unsigned> &map) const
 }
 
 
-AliHLTEventDDL AliHLTCTPData::ReadoutList(const AliHLTComponentTriggerData& trigData) const
+AliHLTReadoutList AliHLTCTPData::ReadoutList(const AliHLTComponentTriggerData& trigData) const
 {
   // see header file for function documentation
-  if (trigData.fDataSize != sizeof(AliHLTEventTriggerData)) {
-    HLTError("invalid trigger data size: %d expected %d", trigData.fDataSize, sizeof(AliHLTEventTriggerData));
-    AliHLTEventDDL dummy;
-    memset(&dummy, 0, sizeof(AliHLTEventDDL));
-    return dummy;
-  }
 
+  const AliRawDataHeader* cdh = NULL;
+  if (AliHLTComponent::ExtractTriggerData(trigData, NULL, NULL, &cdh, NULL, true) != 0) return AliHLTReadoutList();
   // trigger mask is 50 bit wide and is stored in word 5 and 6 of the CDH
-  AliHLTEventTriggerData* evtData=reinterpret_cast<AliHLTEventTriggerData*>(trigData.fData);
-  AliHLTUInt64_t triggerMask=evtData->fCommonHeader[6]&0x3ffff;
-  triggerMask<<=32;
-  triggerMask|=evtData->fCommonHeader[5];
+  AliHLTUInt64_t triggerMask = cdh->GetTriggerClasses();
 
   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]);
   }
@@ -453,7 +437,7 @@ AliHLTEventDDL AliHLTCTPData::ReadoutList(const AliHLTComponentTriggerData& trig
   return ReadoutList(triggerMask);
 }
 
-AliHLTEventDDL AliHLTCTPData::ReadoutList(AliHLTUInt64_t  triggerMask) const
+AliHLTReadoutList AliHLTCTPData::ReadoutList(AliHLTUInt64_t  triggerMask) const
 {
   // take an 'OR' of all active trigger classes 
   AliHLTReadoutList list;
index 427ff95..42d8e16 100644 (file)
@@ -18,6 +18,8 @@
 #include "TArrayL64.h"
 #include "AliHLTLogging.h"
 #include "AliHLTDataTypes.h"
+#include "AliHLTReadoutList.h"
+
 
 /**
  * @class AliHLTCTPData
@@ -139,19 +141,19 @@ 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.
    */
-  AliHLTEventDDL ReadoutList(const AliHLTComponentTriggerData& trigData) const;
+  AliHLTReadoutList ReadoutList(const AliHLTComponentTriggerData& trigData) const;
 
   /**
    * Return a readout list for the active trigger classes.
    * The list is an 'OR' of the active trugger classes.
    */
-  AliHLTEventDDL ReadoutList(AliHLTUInt64_t  triggerMask) const;
+  AliHLTReadoutList ReadoutList(AliHLTUInt64_t  triggerMask) const;
 
   /**
    * Return a readout list for the active trigger classes.
    * The list is an 'OR' of the active trugger classes.
    */
-  AliHLTEventDDL ReadoutList() const {
+  AliHLTReadoutList ReadoutList() const {
     return ReadoutList(fTriggers);
   }
 
index b385c3f..6fa09b2 100644 (file)
@@ -33,6 +33,7 @@ using namespace std;
 
 #include "AliHLTCalibrationProcessor.h"
 #include "AliHLTMemoryFile.h"
+#include "AliHLTReadoutList.h"
 
 #include <cstdlib>
 #include <cerrno>
@@ -210,39 +211,6 @@ Int_t AliHLTCalibrationProcessor::DoEvent( const AliHLTComponentEventData& evtDa
 
   // ** if event Type is not SOR or EOR -> fill DDLNumber list and process data
   if ( ! blkEOR  && !blkSOR ) {
-
-#if 0    
-    // ** Set DDLNumber List
-    if ( trigData.fData != NULL) {
-      AliHLTEventTriggerData* trg = ( AliHLTEventTriggerData* ) trigData.fData;
-      if ( trg != NULL) {
-       AliHLTEventDDL list = (AliHLTEventDDL) trg->fReadoutList;        
-         
-       Int_t wordNdx = GetFirstUsedDDLWord(list);
-       if ( wordNdx >=0 ) {
-         
-         Int_t wordCount = 1;
-         // Handle special TPC and TOF case
-         if ( wordNdx == 3 )
-           wordCount = 8;
-         else if ( wordNdx == 12 )
-           wordCount = 3;
-         
-         // check word for word and binary OR it with existing DDLNumberList
-         for ( Int_t ndx = 0; ndx < wordCount; ndx++ ) {
-           AliHLTUInt32_t word = list.fList[wordNdx+ndx];
-       
-           // set only 4 bit into one Char_t
-           for ( Int_t charNdx = 0; charNdx < 8; charNdx++) {
-             fDDLNumber[(8*ndx)+charNdx] |= (Char_t) word & 0x0000000F;
-             word = word >> 4;
-           }
-         }
-       } // if ( wordNdx > 0 ) {
-      } // if ( trg != NULL) {
-    } // if ( trigData.fData != NULL) {
-#endif
-    
     // ** ProcessData
     iResult = ProcessCalibration( evtData, blocks, trigData, outputPtr, size, outputBlocks );
     fEventCounter++; 
@@ -314,7 +282,7 @@ Int_t AliHLTCalibrationProcessor::ShipDataToFXS( const AliHLTComponentEventData&
  * ######################## CreateFXSHeader #####################
  */
 
-Int_t AliHLTCalibrationProcessor::CreateFXSHeader( AliHLTFXSHeader &pHeader, const char* pDetector, const char* pFileID, AliHLTEventDDL* pDDLList ) {
+Int_t AliHLTCalibrationProcessor::CreateFXSHeader( AliHLTFXSHeader &pHeader, const char* pDetector, const char* pFileID, const AliHLTReadoutList* pDDLList ) {
   // see header file for class documentation
 
   Int_t iResult = 0;
@@ -345,19 +313,23 @@ Int_t AliHLTCalibrationProcessor::CreateFXSHeader( AliHLTFXSHeader &pHeader, con
   if ( pDDLList ) {
     // use user list
     
-    Int_t wordNdx = GetFirstUsedDDLWord( *(pDDLList) );
-    if ( wordNdx >=0 ) {
-         
-      Int_t wordCount = 1;
-      // Handle special TPC and TOF case
-      if ( wordNdx == 3 )
-       wordCount = 8;
-      else if ( wordNdx == 12 )
-       wordCount = 3;
-         
+    AliHLTReadoutList::EDetectorId detid = pDDLList->GetFirstUsedDetector();
+    Int_t wordNdx = AliHLTReadoutList::GetFirstWord(detid);
+    Int_t wordCount = AliHLTReadoutList::GetWordCount(detid);
+    
+    if (pDDLList->GetFirstUsedDetector(detid) != AliHLTReadoutList::kNoDetector or wordNdx < 0)
+    {
+      HLTError("DDLIDs for minimum of TWO detectors ( %s, %s ) set, this function works only for ONE detector.",
+          AliHLTReadoutList::DetectorIdToString(detid),
+          AliHLTReadoutList::DetectorIdToString(pDDLList->GetFirstUsedDetector(detid))
+        );
+      iResult = -1;
+    }
+    else
+    {
       // check word for word 
       for ( Int_t ndx = 0; ndx < wordCount; ndx++ ) {
-       AliHLTUInt32_t word = pDDLList->fList[wordNdx+ndx];
+       AliHLTUInt32_t word = pDDLList->Buffer()->fList[wordNdx+ndx];
        
        // set only 4 bit into one Char_t
        for ( Int_t charNdx = 0; charNdx < 8; charNdx++) {
@@ -365,9 +337,7 @@ Int_t AliHLTCalibrationProcessor::CreateFXSHeader( AliHLTFXSHeader &pHeader, con
          word = word >> 4;
        }
       }
-    } // if ( wordNdx > 0 ) {
-    else
-      iResult = wordNdx;
+    }
   } //   if ( pDDLList ) {
 
   // -- fill header with ascii chars
@@ -381,13 +351,13 @@ Int_t AliHLTCalibrationProcessor::CreateFXSHeader( AliHLTFXSHeader &pHeader, con
   }
   
   return iResult;
-}  // Int_t AliHLTCalibrationProcessor::CreateFXSHeader( AliHLTXSHeader &pHeader, const char* pDetector, const char* pFileID, AliHLTEventDDL* pDDLList ) {
+}  // Int_t AliHLTCalibrationProcessor::CreateFXSHeader( AliHLTXSHeader &pHeader, const char* pDetector, const char* pFileID, const AliHLTReadoutList* pDDLList ) {
 
 /*
  * ######################## PushToFXS #####################
  */
 
-Int_t AliHLTCalibrationProcessor::PushToFXS(TObject* pObject, const char* pDetector, const char* pFileID, AliHLTEventDDL* pDDLList ) {
+Int_t AliHLTCalibrationProcessor::PushToFXS(TObject* pObject, const char* pDetector, const char* pFileID, const AliHLTReadoutList* pDDLList ) {
   // see header file for class documentation
 
   Int_t iResult = 0;
@@ -426,9 +396,9 @@ Int_t AliHLTCalibrationProcessor::PushToFXS(TObject* pObject, const char* pDetec
 
   return iResult;
 
-} // Int_t AliHLTCalibrationProcessor::PushToFXS(TObject* pObject, const char* detector, const char* pFileID, AliHLTEventDDL* pDDLList ) {
+} // Int_t AliHLTCalibrationProcessor::PushToFXS(TObject* pObject, const char* detector, const char* pFileID, const AliHLTReadoutList* pDDLList ) {
 
-Int_t AliHLTCalibrationProcessor::PushToFXS( void* pBuffer, int iSize, const char* pDetector, const char* pFileID, AliHLTEventDDL* pDDLList ) {
+Int_t AliHLTCalibrationProcessor::PushToFXS( void* pBuffer, int iSize, const char* pDetector, const char* pFileID, const AliHLTReadoutList* pDDLList ) {
   // see header file for class documentation
 
   Int_t iResult = 0;
@@ -441,5 +411,5 @@ Int_t AliHLTCalibrationProcessor::PushToFXS( void* pBuffer, int iSize, const cha
 
   return iResult;
 
-} // Int_t AliHLTCalibrationProcessor::PushToFXS(void* pBuffer, int iSize, const char* pDdetector, const char* pFileID, AliHLTEventDDL* pDDLList ) {
+} // Int_t AliHLTCalibrationProcessor::PushToFXS(void* pBuffer, int iSize, const char* pDdetector, const char* pFileID, const AliHLTReadoutList* pDDLList ) {
 
index 5987012..00290e6 100644 (file)
@@ -19,6 +19,8 @@
 #include "AliHLTMessage.h"
 #include "AliHLTDataTypes.h"
 
+class AliHLTReadoutList;
+
 /**
  * @class AliHLTCalibrationProcessor
  * Base class of HLT calibration components.
@@ -59,13 +61,13 @@ class AliHLTCalibrationProcessor : public AliHLTProcessor {
    * @param pObject     pointer to root object
    * @param pDetector   4 byte Detector identifier
    * @param pFileID     name of the file to which the data shall be stored
-   * @param pDDLList    pointer to ReadoutList ( struct @ref AliHLTEventDDL) of
+   * @param pDDLList    pointer to ReadoutList ( class @ref AliHLTReadoutList) of
    *                    participating DDLs. Have to be set or unset with @ref
    *                    AliHLTComponent::EnableDDLBit() and @ref AliHLTComponent::DisableDDLBit(). 
    *                   Will be filled automatically if not supplied by the component.
    * @return neg. error code if failed 
    */
-  Int_t PushToFXS(TObject* pObject, const char* pDetector, const char* pFileID, AliHLTEventDDL* pDDLList);
+  Int_t PushToFXS(TObject* pObject, const char* pDetector, const char* pFileID, const AliHLTReadoutList* pDDLList);
 
   /**
    * Insert an object into the output. FXS header will be inserted before the root object.
@@ -73,13 +75,13 @@ class AliHLTCalibrationProcessor : public AliHLTProcessor {
    * @param iSize       size of the buffer
    * @param pDetector   4 byte Detector identifier
    * @param pFileID     name of the file to which the data shall be stored
-   * @param pDDLList    pointer to ReadoutList ( struct @ref AliHLTEventDDL) of
+   * @param pDDLList    pointer to ReadoutList ( class @ref AliHLTReadoutList) of
    *                    participating DDLs. Have to be set or unset with @ref
    *                    AliHLTComponent::EnableDDLBit() and @ref AliHLTComponent::DisableDDLBit().
    *                   Will be filled automatically if not supplied by the component.
    * @return neg. error code if failed 
    */
-   Int_t PushToFXS(void* pBuffer, int iSize, const char* pDetector, const char* pFileID, AliHLTEventDDL* pDDLList);
+   Int_t PushToFXS(void* pBuffer, int iSize, const char* pDetector, const char* pFileID, const AliHLTReadoutList* pDDLList);
 
   /** Constants  */ 
   static const AliHLTUInt32_t fgkFXSProtocolHeaderSize;
@@ -242,12 +244,12 @@ class AliHLTCalibrationProcessor : public AliHLTProcessor {
    * @param pHeader     pointer to AliHLTFXSHeader
    * @param pDetector   4 byte Detector identifier
    * @param pFileID     name of the file to which the data shall be stored
-   * @param pDDLList    pointer to ReadoutList ( struct @ref AliHLTEventDDL) of
+   * @param pDDLList    pointer to ReadoutList ( class @ref AliHLTReadoutList) of
    *                    participating DDLs. Will be filled automatically if not 
    *                    supplied by the component.
    * @return neg. error code if failed 
    */
-  Int_t CreateFXSHeader( AliHLTFXSHeader &pHeader, const char* pDetector, const char* pFileID, AliHLTEventDDL* pDDLList );
+  Int_t CreateFXSHeader( AliHLTFXSHeader &pHeader, const char* pDetector, const char* pFileID, const AliHLTReadoutList* pDDLList );
 
   /*
    * ######################## Members #####################
index aa7c05a..6f859b1 100644 (file)
@@ -34,6 +34,7 @@ using namespace std;
 #include "AliHLTComponentHandler.h"
 #include "AliHLTMessage.h"
 #include "AliHLTCTPData.h"
+#include "AliRawDataHeader.h"
 #include "TString.h"
 #include "TMath.h"
 #include "TObjArray.h"
@@ -84,7 +85,6 @@ AliHLTComponent::AliHLTComponent()
   fpStopwatches(new TObjArray(kSWTypeCount)),
   fMemFiles(),
   fpRunDesc(NULL),
-  fpDDLList(NULL),
   fCDBSetRunNoFunc(false),
   fChainId(),
   fChainIdCrc(0),
@@ -2278,73 +2278,6 @@ int AliHLTComponent::CopyStruct(void* pStruct, unsigned int iStructSize, unsigne
   return iResult;
 }
 
-void AliHLTComponent::SetDDLBit(AliHLTEventDDL &list, Int_t ddlId, Bool_t state ) const
-{
-  // see header file for function documentation
-  
-  // -- Detector offset
-  Int_t ddlIdBase =  TMath::FloorNint( (Double_t) ddlId / 256.0 );
-  
-  // -- Word Base = 1. word of detector ( TPC has 8 words, TOF 3 ) 
-  Int_t wordBase = 0;
-
-  if ( ddlIdBase <= 3 )
-    wordBase = ddlIdBase;
-  else if ( ddlIdBase > 3 && ddlIdBase < 5 )
-    wordBase = ddlIdBase + 7;
-  else 
-    wordBase = ddlIdBase + 9;
-
-  // -- Bit index in Word
-  Int_t bitIdx = ddlId % 32;
-
-  // -- Index of word
-  Int_t wordIdx = wordBase;
-
-  // -- if TPC (3) or TOD (5) add word idx
-  if ( ( ddlIdBase == 3 ) || ( ddlIdBase == 5 ) ) {
-    wordIdx += TMath::FloorNint( (Double_t) ( ddlId - ( ddlIdBase * 256 ) ) / 32.0 );
-  }
-
-  // -- Set -- 'OR' word with bit mask;
-  if ( state )
-    list.fList[wordIdx] |= ( 0x00000001 << bitIdx );
-  // -- Unset -- 'AND' word with bit mask;
-  else
-    list.fList[wordIdx] &= ( 0xFFFFFFFF ^ ( 0x00000001 << bitIdx ) );
-}
-
-Int_t AliHLTComponent::GetFirstUsedDDLWord(AliHLTEventDDL &list) const
-{
-  // see header file for function documentation
-
-  Int_t iResult = -1;
-
-  for ( Int_t wordNdx = 0 ; wordNdx < gkAliHLTDDLListSize ; wordNdx++ ) {
-
-    if ( list.fList[wordNdx] != 0 && iResult == -1 ) {
-      // check for special cases TPC and TOF
-      if ( wordNdx > 3 && wordNdx <= 10 ) {
-       wordNdx = 10;
-       iResult = 3;
-      }
-      else if ( wordNdx > 12 && wordNdx <= 14 ) {
-       wordNdx = 14;
-       iResult = 12;
-      }
-      else
-       iResult = wordNdx;
-    }
-    else if ( list.fList[wordNdx] != 0 && iResult >= 0 ) {
-      HLTError( "DDLIDs for minimum of TWO detectors ( %d, %d ) set, this function works only for ONE detector.", iResult, wordNdx );
-      iResult = -1;
-      break;
-    }
-  }
-
-  return iResult;
-}
-
 AliHLTUInt32_t AliHLTComponent::CalculateChecksum(const AliHLTUInt8_t* buffer, int size)
 {
   // see header file for function documentation
@@ -2455,6 +2388,101 @@ int AliHLTComponent::ExtractComponentTableEntry(const AliHLTUInt8_t* pBuffer, Al
   return 1;
 }
 
+int AliHLTComponent::ExtractTriggerData(
+    const AliHLTComponentTriggerData& trigData,
+    const AliHLTUInt8_t (**attributes)[gkAliHLTBlockDAttributeCount],
+    AliHLTUInt64_t* status,
+    const AliRawDataHeader** cdh,
+    AliHLTReadoutList* readoutlist,
+    bool printErrors
+  )
+{
+  // see header file for function documentation
+  
+  // Check that the trigger data structure is the correct size.
+  if (trigData.fStructSize != sizeof(AliHLTComponentTriggerData))
+  {
+    if (printErrors)
+    {
+      AliHLTLogging log;
+      log.LoggingVarargs(kHLTLogError, Class_Name(), FUNCTIONNAME(), __FILE__, __LINE__,
+          "Invalid trigger structure size: %d but expected %d.", trigData.fStructSize, sizeof(AliHLTComponentTriggerData)
+        );
+    }
+    return -ENOENT;
+  }
+  
+  // Check that the trigger data pointer points to data of a size we can handle.
+  // Either it is the size of AliHLTEventTriggerData or 32 bits less for the old
+  // version of AliHLTEventDDL, i.e. AliHLTEventDDLV0.
+  if (trigData.fDataSize != sizeof(AliHLTEventTriggerData) and
+      trigData.fDataSize != sizeof(AliHLTEventTriggerData) - sizeof(AliHLTUInt32_t)
+     )
+  {
+    if (printErrors)
+    {
+      AliHLTLogging log;
+      log.LoggingVarargs(kHLTLogError, Class_Name(), FUNCTIONNAME(), __FILE__, __LINE__,
+          "Invalid trigger data size: %d but expected %d.", trigData.fDataSize, sizeof(AliHLTEventTriggerData)
+        );
+    }
+    return -EBADF;
+  }
+  
+  AliHLTEventTriggerData* evtData = reinterpret_cast<AliHLTEventTriggerData*>(trigData.fData);
+  assert(evtData != NULL);
+  
+  // Check that the CDH has 8 words.
+  if (cdh != NULL and evtData->fCommonHeaderWordCnt != 8)
+  {
+    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)
+        );
+    }
+    return -EBADMSG;
+  }
+  
+  // Check that the readout list has the correct count of words. i.e. something we can handle,
+  if (readoutlist != NULL and
+      evtData->fReadoutList.fCount != (unsigned)gkAliHLTDDLListSizeV0 and
+      evtData->fReadoutList.fCount != (unsigned)gkAliHLTDDLListSizeV1
+     )
+  {
+    if (printErrors)
+    {
+      AliHLTLogging log;
+      log.LoggingVarargs(kHLTLogError, Class_Name(), FUNCTIONNAME(), __FILE__, __LINE__,
+          "Readout list structure has wrong number of data words: %d but expected %d",
+          evtData->fReadoutList.fCount, gkAliHLTDDLListSize
+        );
+    }
+    return -EPROTO;
+  }
+  
+  if (attributes != NULL)
+  {
+    *attributes = &evtData->fAttributes;
+  }
+  if (status != NULL)
+  {
+    *status = evtData->fHLTStatus;
+  }
+  if (cdh != NULL)
+  {
+    const AliRawDataHeader* cdhptr = reinterpret_cast<const AliRawDataHeader*>(&evtData->fCommonHeader);
+    *cdh = cdhptr;
+  }
+  if (readoutlist != NULL)
+  {
+    *readoutlist = AliHLTReadoutList(evtData->fReadoutList);
+  }
+  return 0;
+}
+
 int AliHLTComponent::LoggingVarargs(AliHLTComponentLogSeverity severity, 
                                    const char* originClass, const char* originFunc,
                                    const char* file, int line, ... ) const
index cfcc1a6..828f091 100644 (file)
@@ -82,9 +82,11 @@ class AliHLTComponentHandler;
 class TObjArray;
 class TMap;
 class TStopwatch;
+class AliRawDataHeader;
 class AliHLTComponent;
 class AliHLTMemoryFile;
 class AliHLTCTPData;
+class AliHLTReadoutList;
 
 /** list of component data type structures */
 typedef vector<AliHLTComponentDataType>   AliHLTComponentDataTypeList;
@@ -720,6 +722,58 @@ class AliHLTComponent : public AliHLTLogging {
   static int ExtractComponentTableEntry(const AliHLTUInt8_t* pBuffer, AliHLTUInt32_t size,
                                        string& chainId, string& compId, string& compParam,
                                        vector<AliHLTUInt32_t>& parents);
+
+  /**
+   * Extracts the different data parts from the trigger data structure.
+   * [in] @param trigData  The trigger data as passed to the DoProcessing method.
+   * [out] @param attributes  The data block attributes given by the HLT framework.
+   * [out] @param status  The HLT status bits given by the HLT framework.
+   * [out] @param cdh  The common data header received from DDL links.
+   * [out] @param readoutlist  The readout list to fill with readout list bits
+   *                           passed on by the HLT framework.
+   * [in] @param printErrors  If true then error messages are generated as necessary
+   *                          and suppressed otherwise.
+   * @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;
+   *     ExtractTriggerData(trigData, NULL, NULL, &cdh, NULL);
+   *   \endcode
+   * @return the zero on success and one of the following error codes on failure.
+   *   if a non-zero error code is returned then none of the output parameters are
+   *   modified.
+   *    \li -ENOENT  The <i>trigData</i> structure size is wrong.
+   *    \li -EBADF   The <i>trigData</i> data size is wrong.
+   *    \li -EBADMSG The common data header (CDH) in the trigger data has the wrong
+   *                 number of words indicated.
+   *    \li -EPROTO  The readout list structure in the trigger data has the wrong
+   *                 number of words indicated.
+   */
+  static int ExtractTriggerData(
+      const AliHLTComponentTriggerData& trigData,
+      const AliHLTUInt8_t (**attributes)[gkAliHLTBlockDAttributeCount],
+      AliHLTUInt64_t* status,
+      const AliRawDataHeader** cdh,
+      AliHLTReadoutList* readoutlist,
+      bool printErrors = false
+    );
+
+  /**
+   * Extracts the readout list from a trigger data structure.
+   * [in] @param trigData  The trigger data as passed to the DoProcessing method.
+   * [out] @param list  The output readout list to fill.
+   * [in] @param printErrors  If true then error messages are generated as necessary
+   *                          and suppressed otherwise.
+   * @return the zero on success or one of the error codes returned by ExtractTriggerData.
+   */
+  static int GetReadoutList(
+      const AliHLTComponentTriggerData& trigData, AliHLTReadoutList& list,
+      bool printErrors = false
+    )
+  {
+    return ExtractTriggerData(trigData, NULL, NULL, NULL, &list, printErrors);
+  }
+  
   /**
    * Stopwatch type for benchmarking.
    */
@@ -1474,46 +1528,6 @@ class AliHLTComponent : public AliHLTLogging {
   bool IsDataEvent(AliHLTUInt32_t* pTgt=NULL) const;
 
   /**
-   * Set a bit to 1 in a readout list ( = AliHLTEventDDL )
-   * -> enable DDL for readout
-   * @param list        readout list
-   * @param ddlId       DDL Id to be turned on ( Decimal )
-   */
-  void EnableDDLBit(AliHLTEventDDL &list, Int_t ddlId ) const {
-    SetDDLBit( list, ddlId, kTRUE ); 
-  }
-
-  /**
-   * Set a bit to 0 in a readout list ( = AliHLTEventDDL )
-   * -> disable DDL for readout
-   * @param list        readout list
-   * @param ddlId       DDL Id to be turned on ( Decimal )
-   */
-  void DisableDDLBit(AliHLTEventDDL &list, Int_t ddlId ) const { 
-    SetDDLBit( list, ddlId, kFALSE );  
-  }
-  
-  /**
-   * Set or unset  bit a readout list ( = AliHLTEventDDL )
-   * -> enable or disable DDL for readout
-   * @param list        readout list
-   * @param ddlId       DDL Id to be turned on ( Decimal )
-   * @param state       kTRUE sets it, kFALSE unsets it
-   */
-  void SetDDLBit(AliHLTEventDDL &list, Int_t ddlId, Bool_t state ) const;
-  
-  /**
-   * Get the first word of a detector, which has a set DDL bit. 
-   * Beware, this only works if DDLs of 1 detector are set. In the 
-   * case of the TPC and TOF, which use 8 and 3 words, the first 
-   * word is returned.
-   * @param list        readout list
-   * @return            returns the detector index, -1 if no bit is set
-   *                    at all or several detectors (=error)
-   */
-  Int_t GetFirstUsedDDLWord(AliHLTEventDDL &list) const;
-
-  /**
    * Copy a struct from block data.
    * The function checks for block size and struct size. The least common
    * size will be copied to the target struct, remaining fields are initialized
@@ -1727,9 +1741,6 @@ class AliHLTComponent : public AliHLTLogging {
   /** descriptor of the current run */
   AliHLTRunDesc* fpRunDesc;                                        //! transient
 
-  /** the current DDL list */
-  AliHLTEventDDL* fpDDLList;                                       //! transient
-
   /** external fct to set CDB run no, indicates external CDB initialization */
   void (*fCDBSetRunNoFunc)();                                      //! transient
 
index a975ff6..287002a 100644 (file)
 ClassImp(AliHLTReadoutList)
 
 
+const char* AliHLTReadoutList::DetectorIdToString(EDetectorId id)
+{
+  // Converts a detector ID to a user readable string.
+  switch (id)
+  {
+  case kNoDetector: return "kNoDetector";
+  case kITSSPD:  return "kITSSPD";
+  case kITSSDD:  return "kITSSDD";
+  case kITSSSD:  return "kITSSSD";
+  case kTPC:     return "kTPC";
+  case kTRD:     return "kTRD";
+  case kTOF:     return "kTOF";
+  case kHMPID:   return "kHMPID";
+  case kPHOS:    return "kPHOS";
+  case kCPV:     return "kCPV";
+  case kPMD:     return "kPMD";
+  case kMUONTRK: return "kMUONTRK";
+  case kMUONTRG: return "kMUONTRG";
+  case kFMD:     return "kFMD";
+  case kT0:      return "kT0";
+  case kV0:      return "kV0";
+  case kZDC:     return "kZDC";
+  case kACORDE:  return "kACORDE";
+  case kTRG:     return "kTRG";
+  case kEMCAL:   return "kEMCAL";
+  case kDAQTEST: return "kDAQTEST";
+  case kHLT:     return "kHLT";
+  case kALLDET:  return "kALLDET";
+  default:       return "UNKNOWN!";
+  }
+}
+
+
 AliHLTReadoutList::AliHLTReadoutList() :
         TNamed("AliHLTReadoutList", "Readout list object used for manipulating and storing an AliHLTEventDDL structure."),
        fReadoutList()
@@ -119,10 +152,24 @@ AliHLTReadoutList::AliHLTReadoutList(const AliHLTEventDDL& list) :
 {
   // Constructor to create readout list from AliHLTEventDDL structure.
   // See header file for more details.
-  memset(&fReadoutList, 0, sizeof(fReadoutList));
-  // handle lists of different sizes, copy only the overlapping part of the list
-  fReadoutList.fCount=sizeof(fReadoutList.fList)/sizeof(AliHLTUInt32_t);
-  memcpy(&fReadoutList.fList, &list.fList, (fReadoutList.fCount<list.fCount?fReadoutList.fCount:list.fCount)*sizeof(AliHLTUInt32_t));
+  fReadoutList.fCount = gkAliHLTDDLListSize;  // Required by ALICE-INT-2007-015
+  memset(fReadoutList.fList, 0x0, sizeof(fReadoutList.fList));
+  // Handle lists of different sizes. If the size is for a known version
+  // of AliHLTEventDDL then handle appropriately, otherwise just copy only
+  // the overlapping part of the list.
+  if (list.fCount == gkAliHLTDDLListSizeV0)
+  {
+    memcpy(&fReadoutList.fList[0], &list.fList[0], sizeof(AliHLTUInt32_t)*28);
+    memcpy(&fReadoutList.fList[29], &list.fList[28], sizeof(AliHLTUInt32_t)*2);
+  }
+  else if (list.fCount == gkAliHLTDDLListSizeV1)
+  {
+    memcpy(&fReadoutList.fList, &list.fList, sizeof(AliHLTEventDDL));
+  }
+  else
+  {
+    memcpy(&fReadoutList.fList, &list.fList, (fReadoutList.fCount<list.fCount?fReadoutList.fCount:list.fCount)*sizeof(AliHLTUInt32_t));
+  }
 }
 
 
@@ -411,6 +458,156 @@ bool AliHLTReadoutList::DetectorEnabled(Int_t detector) const
 }
 
 
+bool AliHLTReadoutList::DetectorDisabled(Int_t detector) const
+{
+  // Checks if a particular detector's DDLs are disabled.
+  // See header file for more details.
+  
+  bool result = true;
+  if ((detector & kITSSPD) != 0) result &= fReadoutList.fList[0] == 0x00000000;
+  if ((detector & kITSSDD) != 0) result &= fReadoutList.fList[1] == 0x00000000;
+  if ((detector & kITSSSD) != 0) result &= fReadoutList.fList[2] == 0x00000000;
+  if ((detector & kTPC) != 0)
+  {
+    result &= fReadoutList.fList[3] == 0x00000000;
+    result &= fReadoutList.fList[4] == 0x00000000;
+    result &= fReadoutList.fList[5] == 0x00000000;
+    result &= fReadoutList.fList[6] == 0x00000000;
+    result &= fReadoutList.fList[7] == 0x00000000;
+    result &= fReadoutList.fList[8] == 0x00000000;
+    result &= fReadoutList.fList[9] == 0x00000000;
+  }
+  if ((detector & kTRD) != 0) result &= fReadoutList.fList[11] == 0x00000000;
+  if ((detector & kTOF) != 0)
+  {
+    result &= fReadoutList.fList[12] == 0x00000000;
+    result &= fReadoutList.fList[13] == 0x00000000;
+    result &= fReadoutList.fList[14] == 0x00000000;
+  }
+  if ((detector & kHMPID) != 0) result &= fReadoutList.fList[15] == 0x00000000;
+  if ((detector & kPHOS) != 0) result &= fReadoutList.fList[16] == 0x00000000;
+  if ((detector & kCPV) != 0) result &= fReadoutList.fList[17] == 0x00000000;
+  if ((detector & kPMD) != 0) result &= fReadoutList.fList[18] == 0x00000000;
+  if ((detector & kMUONTRK) != 0) result &= fReadoutList.fList[19] == 0x00000000;
+  if ((detector & kMUONTRG) != 0) result &= fReadoutList.fList[20] == 0x00000000;
+  if ((detector & kFMD) != 0) result &= fReadoutList.fList[21] == 0x00000000;
+  if ((detector & kT0) != 0) result &= fReadoutList.fList[22] == 0x00000000;
+  if ((detector & kV0) != 0) result &= fReadoutList.fList[23] == 0x00000000;
+  if ((detector & kZDC) != 0) result &= fReadoutList.fList[24] == 0x00000000;
+  if ((detector & kACORDE) != 0) result &= fReadoutList.fList[25] == 0x00000000;
+  if ((detector & kTRG) != 0) result &= fReadoutList.fList[26] == 0x00000000;
+  if ((detector & kEMCAL) != 0)
+  {
+    result &= fReadoutList.fList[27] == 0x00000000;
+    result &= fReadoutList.fList[28] == 0x00000000;
+  }
+  if ((detector & kDAQTEST) != 0) result &= fReadoutList.fList[29] == 0x00000000;
+  if ((detector & kHLT) != 0) result &= fReadoutList.fList[30] == 0x00000000;
+  
+  return result;
+}
+
+
+Int_t AliHLTReadoutList::GetFirstWord(EDetectorId detector)
+{
+  // See header file for more details.
+  switch (detector)
+  {
+  case kITSSPD:  return 0;
+  case kITSSDD:  return 1;
+  case kITSSSD:  return 2;
+  case kTPC:     return 3;
+  case kTRD:     return 11;
+  case kTOF:     return 12;
+  case kHMPID:   return 15;
+  case kPHOS:    return 16;
+  case kCPV:     return 17;
+  case kPMD:     return 18;
+  case kMUONTRK: return 19;
+  case kMUONTRG: return 20;
+  case kFMD:     return 21;
+  case kT0:      return 22;
+  case kV0:      return 23;
+  case kZDC:     return 24;
+  case kACORDE:  return 25;
+  case kTRG:     return 26;
+  case kEMCAL:   return 27;
+  case kDAQTEST: return 29;
+  case kHLT:     return 30;
+  default:       return -1;
+  }
+}
+
+
+Int_t AliHLTReadoutList::GetWordCount(EDetectorId detector)
+{
+  // See header file for more details.
+  switch (detector)
+  {
+  case kITSSPD:  return 1;
+  case kITSSDD:  return 1;
+  case kITSSSD:  return 1;
+  case kTPC:     return 8;
+  case kTRD:     return 1;
+  case kTOF:     return 3;
+  case kHMPID:   return 1;
+  case kPHOS:    return 1;
+  case kCPV:     return 1;
+  case kPMD:     return 1;
+  case kMUONTRK: return 1;
+  case kMUONTRG: return 1;
+  case kFMD:     return 1;
+  case kT0:      return 1;
+  case kV0:      return 1;
+  case kZDC:     return 1;
+  case kACORDE:  return 1;
+  case kTRG:     return 1;
+  case kEMCAL:   return 2;
+  case kDAQTEST: return 1;
+  case kHLT:     return 1;
+  default:       return 0;
+  }
+}
+
+
+AliHLTReadoutList::EDetectorId AliHLTReadoutList::GetFirstUsedDetector(EDetectorId startAfter) const
+{
+  // See header file for more details.
+  if (startAfter < kITSSPD and fReadoutList.fList[0] != 0x00000000) return kITSSPD;
+  if (startAfter < kITSSDD and fReadoutList.fList[1] != 0x00000000) return kITSSDD;
+  if (startAfter < kITSSSD and fReadoutList.fList[2] != 0x00000000) return kITSSSD;
+  if (startAfter < kTPC and fReadoutList.fList[3] != 0x00000000) return kTPC;
+  if (startAfter < kTPC and fReadoutList.fList[4] != 0x00000000) return kTPC;
+  if (startAfter < kTPC and fReadoutList.fList[5] != 0x00000000) return kTPC;
+  if (startAfter < kTPC and fReadoutList.fList[6] != 0x00000000) return kTPC;
+  if (startAfter < kTPC and fReadoutList.fList[7] != 0x00000000) return kTPC;
+  if (startAfter < kTPC and fReadoutList.fList[8] != 0x00000000) return kTPC;
+  if (startAfter < kTPC and fReadoutList.fList[9] != 0x00000000) return kTPC;
+  if (startAfter < kTPC and fReadoutList.fList[10] != 0x00000000) return kTPC;
+  if (startAfter < kTRD and fReadoutList.fList[11] != 0x00000000) return kTRD;
+  if (startAfter < kTOF and fReadoutList.fList[12] != 0x00000000) return kTOF;
+  if (startAfter < kTOF and fReadoutList.fList[13] != 0x00000000) return kTOF;
+  if (startAfter < kTOF and fReadoutList.fList[14] != 0x00000000) return kTOF;
+  if (startAfter < kHMPID and fReadoutList.fList[15] != 0x00000000) return kHMPID;
+  if (startAfter < kPHOS and fReadoutList.fList[16] != 0x00000000) return kPHOS;
+  if (startAfter < kCPV and fReadoutList.fList[17] != 0x00000000) return kCPV;
+  if (startAfter < kPMD and fReadoutList.fList[18] != 0x00000000) return kPMD;
+  if (startAfter < kMUONTRK and fReadoutList.fList[19] != 0x00000000) return kMUONTRK;
+  if (startAfter < kMUONTRG and fReadoutList.fList[20] != 0x00000000) return kMUONTRG;
+  if (startAfter < kFMD and fReadoutList.fList[21] != 0x00000000) return kFMD;
+  if (startAfter < kT0 and fReadoutList.fList[22] != 0x00000000) return kT0;
+  if (startAfter < kV0 and fReadoutList.fList[23] != 0x00000000) return kV0;
+  if (startAfter < kZDC and fReadoutList.fList[24] != 0x00000000) return kZDC;
+  if (startAfter < kACORDE and fReadoutList.fList[25] != 0x00000000) return kACORDE;
+  if (startAfter < kTRG and fReadoutList.fList[26] != 0x00000000) return kTRG;
+  if (startAfter < kEMCAL and fReadoutList.fList[27] != 0x00000000) return kEMCAL;
+  if (startAfter < kEMCAL and fReadoutList.fList[28] != 0x00000000) return kEMCAL;
+  if (startAfter < kDAQTEST and fReadoutList.fList[29] != 0x00000000) return kDAQTEST;
+  if (startAfter < kHLT and fReadoutList.fList[30] != 0x00000000) return kHLT;
+  return kNoDetector;
+}
+
+
 void AliHLTReadoutList::Print(Option_t* /*option*/) const
 {
   // Prints the DDLs that will be readout according to this readout list.
index f835d6d..932ada3 100644 (file)
@@ -41,6 +41,7 @@ class AliHLTReadoutList : public TNamed
    */
   enum EDetectorId
   {
+    kNoDetector = 0,       /// No detector value
     kITSSPD = 0x1 << 0,    /// ID for SPD detector
     kITSSDD = 0x1 << 1,    /// ID for SDD detector
     kITSSSD = 0x1 << 2,    /// ID for SSD detector
@@ -68,6 +69,9 @@ class AliHLTReadoutList : public TNamed
                | kACORDE | kTRG | kEMCAL | kHLT)
   };
   
+  /// Converts a detector ID to a user readable string.
+  static const char* DetectorIdToString(EDetectorId id);
+  
   /**
    * Default constructor.
    */
@@ -186,12 +190,45 @@ class AliHLTReadoutList : public TNamed
   void Disable(Int_t detector);
   
   /**
-   * Checks if a particular detector's DDLs are enabled for readout.
+   * Checks if a particular detector's DDLs are all enabled for readout.
    * \param detector  A bitmap of detectors to check. Should be any values from
    *    EDetectorId that can be or'ed together for multiple detector selection.
    * \return true if all DDLs for the specified detectors are enabled for readout.
    */
-  bool DetectorEnabled(Int_t ddlId) const;
+  bool DetectorEnabled(Int_t detector) const;
+  
+  /**
+   * Checks if a particular detector's DDLs are all disabled for readout.
+   * \param detector  A bitmap of detectors to check. Should be any values from
+   *    EDetectorId that can be or'ed together for multiple detector selection.
+   * \return true if all DDLs for the specified detectors are disabled for readout.
+   * \note If both DetectorEnabled(x) and DetectorDisabled(x) return false then
+   *    it means that only part of the detectors DDLs are enabled.
+   */
+  bool DetectorDisabled(Int_t detector) const;
+  
+  /**
+   * Returns the first word of DDL bits for a given detector in the internal structure.
+   * \param detector  The detector code for which to return the starting word.
+   * \returns the first word of DDL bits for the detector or -1 if an invalid code is given.
+   */
+  static Int_t GetFirstWord(EDetectorId detector);
+  
+  /**
+   * Returns the first word of DDL bits for a given detector in the internal structure.
+   * \param detector  The detector code for which to return the starting word.
+   * \returns the first word of DDL bits for the detector or -1 if an invalid code is given.
+   */
+  static Int_t GetWordCount(EDetectorId detector);
+  
+  /**
+   * Returns the first detector with non-zero DDL bits.
+   * \param  startAfter  The detector code after which to start looking from.
+   *     If kTOF is used for example then only detectors after kTOF will be checked,
+   *     not including kTOF, in the order of precedence indicated by EDetectorId.
+   * \returns the code of the first used detector.
+   */
+  EDetectorId GetFirstUsedDetector(EDetectorId startAfter = kNoDetector) const;
   
   /**
    * Inherited from TObject. Prints the DDLs that will be readout according to
index fbc639f..653aada 100644 (file)
@@ -209,6 +209,13 @@ bool CheckEnablingDisabling()
                                        << CodeToString(code[j]) << " by constructor." << endl;
                                return false;
                        }
+                       if (rl.DetectorDisabled(code[j]) == true)
+                       {
+                               cerr << "ERROR: DetectorDisabled returned and incorrect result"
+                                       " when detectors enabled for "
+                                       << CodeToString(code[j]) << " by constructor." << endl;
+                               return false;
+                       }
                        
                        // Also check each bit individualy according to AliHLTDAQ values.
                        int det = detNum[j];
@@ -233,6 +240,13 @@ bool CheckEnablingDisabling()
                                        << CodeToString(code[j]) << "." << endl;
                                return false;
                        }
+                       if (rl.DetectorDisabled(code[j]) == false)
+                       {
+                               cerr << "ERROR: DetectorDisabled returned and incorrect result"
+                                       " when calling AliHLTReadoutList::Disable(x) for "
+                                       << CodeToString(code[j]) << "." << endl;
+                               return false;
+                       }
                }
                
                // Fetch the raw bits for the readout list structure and check that they
@@ -385,6 +399,85 @@ bool CheckIncorrectIDs()
 }
 
 /**
+ * Tests if using incorrect DDL IDs returns zero or is ignored as expected.
+ */
+bool CheckWordIndexAndCount()
+{
+       int wordCovered[gkAliHLTDDLListSize];
+       for (int j = 0; j < gkAliHLTDDLListSize; ++j) wordCovered[j] = 0;
+       
+       for (int i = 0; i < kgNumberOfCodes; ++i)
+       {
+               AliHLTReadoutList rl;
+               Int_t firstword = rl.GetFirstWord((AliHLTReadoutList::EDetectorId)kgDetCodes[i]);
+               if (firstword < 0 or gkAliHLTDDLListSize-1 < firstword)
+               {
+                       cerr << "ERROR: AliHLTReadoutList::GetFirstWord(" << kgDetCodeName[i]
+                               << ") returns " << firstword
+                               << ", which is outside the valid range of [0.." << gkAliHLTDDLListSize-1
+                               << "]." << endl;
+                       return false;
+               }
+               
+               Int_t lastword = firstword + rl.GetWordCount((AliHLTReadoutList::EDetectorId)kgDetCodes[i]);
+               if (lastword < 1 or gkAliHLTDDLListSize < lastword)
+               {
+                       cerr << "ERROR: The sum AliHLTReadoutList::GetFirstWord(" << kgDetCodeName[i]
+                               << ") + AliHLTReadoutList::GetWordCount(" << kgDetCodeName[i]
+                               << ") gives " << lastword
+                               << ", which is outside the valid range of [1.." << gkAliHLTDDLListSize
+                               << "]." << endl;
+                       return false;
+               }
+               
+               for (int j = firstword; j < lastword; ++j)
+               {
+                       if (wordCovered[j] == 1)
+                       {
+                               cerr << "ERROR: The combination of AliHLTReadoutList::GetWordCount(" << kgDetCodeName[i]
+                                       << ") and AliHLTReadoutList::GetWordCount(" << kgDetCodeName[i]
+                                       << ") overlaps with previous detectors. Check the mapping in these functions."
+                                       << endl;
+                               return false;
+                       }
+                       wordCovered[j] = 1;
+               }
+               
+               Int_t maxddls = AliHLTDAQ::NumberOfDdls(i);
+               Int_t ddlid = AliHLTDAQ::DdlIDOffset(i) | (gRandom->Integer(maxddls) & 0xFF);
+               rl.EnableDDLBit(ddlid);
+               if (rl.GetFirstUsedDetector() != kgDetCodes[i])
+               {
+                       cerr << "ERROR: AliHLTReadoutList::GetFirstUsedDetector() did not return the correct value of"
+                               << kgDetCodeName[i] << " after calling AliHLTReadoutList::EnableDDLBit("
+                               << ddlid << ")." << endl;
+                       return false;
+               }
+               if (rl.GetFirstUsedDetector((AliHLTReadoutList::EDetectorId)kgDetCodes[i]) != AliHLTReadoutList::kNoDetector)
+               {
+                       cerr << "ERROR: AliHLTReadoutList::GetFirstUsedDetector(" << kgDetCodeName[i]
+                               << "+1) did not return the correct value of AliHLTReadoutList::kNoDetector"
+                                  " after calling AliHLTReadoutList::EnableDDLBit("
+                               << ddlid << ")." << endl;
+                       return false;
+               }
+       }
+       
+       for (int j = 0; j < gkAliHLTDDLListSize; ++j)
+       {
+               if (wordCovered[j] == 0)
+               {
+                       cerr << "ERROR: The functions AliHLTReadoutList::GetWordCount"
+                               " and AliHLTReadoutList::GetWordCount do not fully cover"
+                               " all DDL readout list words." << endl;
+                       return false;
+               }
+       }
+       
+       return true;
+}
+
+/**
  * Runs the unit test for the AliHLTReadoutList class.
  * \returns true if the class passed the test and false otherwise.
  */
@@ -406,6 +499,7 @@ bool testAliHLTReadoutList()
        if (not CheckEnablingDisabling()) return false;
        if (not CheckEnablingDisablingDDLs()) return false;
        if (not CheckIncorrectIDs()) return false;
+       if (not CheckWordIndexAndCount()) return false;
        
        return true;
 }
index 1b0f607..c9aee29 100644 (file)
@@ -100,12 +100,13 @@ int AliHLTReadoutListDumpComponent::DumpEvent( const AliHLTComponentEventData& /
         pBlock && iResult>=0;
         pBlock=GetNextInputBlock()) {
       if (pBlock->fDataType!=hltrdlstdt) continue;
-      if (pBlock->fSize==sizeof(AliHLTEventDDL)) {
+      if (pBlock->fSize==sizeof(AliHLTEventDDL) or pBlock->fSize==sizeof(AliHLTEventDDLV0)) {
        HLTDebug("Filling histograms from binary buffer");
-       FillReadoutListHistogram(fBitsHisto, reinterpret_cast<AliHLTEventDDL*>(pBlock->fPtr));
-       FillReadoutListVsCTP(fBitsVsCTP, reinterpret_cast<AliHLTEventDDL*>(pBlock->fPtr), &trigData);
+       AliHLTReadoutList readoutlist(*reinterpret_cast<AliHLTEventDDL*>(pBlock->fPtr));
+       FillReadoutListHistogram(fBitsHisto, &readoutlist);
+       FillReadoutListVsCTP(fBitsVsCTP, &readoutlist, &trigData);
       } else {
-       HLTError("HLTRDLST size missmatch: %d, expected %d", pBlock->fSize, sizeof(AliHLTEventDDL));
+       HLTError("HLTRDLST size missmatch: %d, expected %d or %d", pBlock->fSize, sizeof(AliHLTEventDDL), sizeof(AliHLTEventDDLV0));
       }
     }
   } else if (fMode==AliHLTReadoutListDumpComponent::kModeHLTDecision) {
@@ -171,23 +172,14 @@ int AliHLTReadoutListDumpComponent::FillReadoutListHistogram(TH1I* histo, const
   // see header file for class documentation
   if (!histo || !list) return -EINVAL;
   if (list->BufferSize()!=sizeof(AliHLTEventDDL)) return -EBADF;
-
-  return FillReadoutListHistogram(histo, list->Buffer());
-}
-
-int AliHLTReadoutListDumpComponent::FillReadoutListHistogram(TH1I* histo, const AliHLTEventDDL* field)
-{
-  // see header file for class documentation
-  if (!histo || !field) return -EINVAL;
-
-  if (field->fCount!=(unsigned)gkAliHLTDDLListSize) return -EBADF;
+  if (list->Buffer()->fCount!=(unsigned)gkAliHLTDDLListSize) return -EBADF;
 
   for (int word=0; word<gkAliHLTDDLListSize; word++) {
     for (unsigned bit=0; bit<sizeof(AliHLTUInt32_t)*8; bit++) {
-      if (field->fList[word]&0x1<<bit) histo->Fill(word*sizeof(AliHLTUInt32_t)*8+bit);
+      if (list->Buffer()->fList[word]&0x1<<bit) histo->Fill(word*sizeof(AliHLTUInt32_t)*8+bit);
     }
   }
-
+  
   return 0;
 }
 
@@ -196,22 +188,13 @@ int AliHLTReadoutListDumpComponent::FillReadoutListVsCTP(TH2I* histo, const AliH
   // see header file for class documentation
   if (!histo || !list || !trigData) return -EINVAL;
   if (list->BufferSize()!=sizeof(AliHLTEventDDL)) return -EBADF;
-
-  return FillReadoutListVsCTP(histo, list->Buffer(), trigData);
-}
-
-int AliHLTReadoutListDumpComponent::FillReadoutListVsCTP(TH2I* histo, const AliHLTEventDDL* field, const AliHLTComponentTriggerData* trigData)
-{
-  // see header file for class documentation
-  if (!histo || !field || !trigData) return -EINVAL;
-
-  if (field->fCount!=(unsigned)gkAliHLTDDLListSize) return -EBADF;
+  if (list->Buffer()->fCount!=(unsigned)gkAliHLTDDLListSize) return -EBADF;
 
   AliHLTUInt64_t triggerMask=AliHLTCTPData::ActiveTriggers(*trigData);
   AliHLTUInt64_t bit0=0x1;
   for (int word=0; word<gkAliHLTDDLListSize; word++) {
     for (unsigned bit=0; bit<sizeof(AliHLTUInt32_t)*8; bit++) {
-      if (field->fList[word]&0x1<<bit) {
+      if (list->Buffer()->fList[word]&0x1<<bit) {
        for (int trigger=0; trigger<gkNCTPTriggerClasses; trigger++) {
          if ((triggerMask&(bit0<<trigger))!=0) {
            histo->Fill(word*sizeof(AliHLTUInt32_t)*8+bit, trigger);
index 527ef31..fd8230b 100644 (file)
@@ -124,18 +124,11 @@ class AliHLTReadoutListDumpComponent : public AliHLTFileWriter
    * Fill histogram from the readout list.
    */
   static int FillReadoutListHistogram(TH1I* histo, const AliHLTReadoutList* list);
-  /**
-   * Fill histogram from the readout list.
-   */
-  static int FillReadoutListHistogram(TH1I* histo, const AliHLTEventDDL* field);
+
   /**
    * Fill histogram from the readout list.
    */
   static int FillReadoutListVsCTP(TH2I* histo, const AliHLTReadoutList* list, const AliHLTComponentTriggerData* trigData);
-  /**
-   * Fill histogram from the readout list.
-   */
-  static int FillReadoutListVsCTP(TH2I* histo, const AliHLTEventDDL* field, const AliHLTComponentTriggerData* trigData);
 
 private:
   /** copy constructor prohibited */
index 7842178..70827bf 100644 (file)
@@ -222,7 +222,7 @@ int AliHLTSampleCalibrationComponent::ShipDataToFXS( const AliHLTComponentEventD
   // prepare final result and ship to FXS
 
   AliHLTReadoutList rdList(AliHLTReadoutList::kHLT);
-  PushToFXS(fHisto, "HLT", "TestHisto", rdList.Buffer());
+  PushToFXS(fHisto, "HLT", "TestHisto", &rdList);
 
   return 0;
 }
index 8d2e882..537f0c9 100644 (file)
@@ -616,7 +616,7 @@ Int_t AliHLTTPCCalibTimeComponent::ShipDataToFXS( const AliHLTComponentEventData
   delete file;
  
   // the vdriftArray is pushed to the HLT-FXSsubscriber 
-  PushToFXS( (TObject*)vdriftArray, "TPC", "TIMEDRIFT", rdList.Buffer() );
+  PushToFXS( (TObject*)vdriftArray, "TPC", "TIMEDRIFT", &rdList );
  
   //Should array be deleted now?
   //  if(vdriftArray){
index a570bdf..3b12869 100644 (file)
@@ -205,7 +205,7 @@ Int_t AliHLTTPCCalibTimeGainComponent::ShipDataToFXS( const AliHLTComponentEvent
     
   if(fEnableAnalysis) fCalibTimeGain->Analyze();  
   static AliHLTReadoutList rdList(AliHLTReadoutList::kTPC);
-  PushToFXS( (TObject*) fCalibTimeGain, "TPC", "TimeGain", rdList.Buffer() ) ;
+  PushToFXS( (TObject*) fCalibTimeGain, "TPC", "TimeGain", &rdList ) ;
   
   return 0;
 } 
index e03072c..1c2a34d 100644 (file)
@@ -228,7 +228,7 @@ Int_t AliHLTTPCCalibrationComponent::ShipDataToFXS( const AliHLTComponentEventDa
     
   if(fEnableAnalysis) fCalibTask->Analyze();  
   static AliHLTReadoutList rdList(AliHLTReadoutList::kTPC);
-  PushToFXS( (TObject*) fCalibTask, "TPC", "CALIB", rdList.Buffer() ) ;
+  PushToFXS( (TObject*) fCalibTask, "TPC", "CALIB", &rdList ) ;
   
   return 0;
 } 
index ef31732..607a8e4 100644 (file)
@@ -256,9 +256,9 @@ Int_t AliHLTTPCOfflineCalibrationComponent::ShipDataToFXS( const AliHLTComponent
       fTPCcalibTracks->Analyze();
    }
    static AliHLTReadoutList rdList(AliHLTReadoutList::kTPC);
-   PushToFXS((TObject*)fTPCcalibAlign, "TPC", "TPCcalibAlign", rdList.Buffer()) ;
-   PushToFXS((TObject*)fTPCcalibTracksGain, "TPC", "TPCcalibTracksGain", rdList.Buffer()) ;
-   PushToFXS((TObject*)fTPCcalibTracks, "TPC", "TPCcalibTracks", rdList.Buffer()) ;
+   PushToFXS((TObject*)fTPCcalibAlign, "TPC", "TPCcalibAlign", &rdList) ;
+   PushToFXS((TObject*)fTPCcalibTracksGain, "TPC", "TPCcalibTracksGain", &rdList) ;
+   PushToFXS((TObject*)fTPCcalibTracks, "TPC", "TPCcalibTracks", &rdList) ;
 
 return 0;
 }
index ef41fec..0dfa286 100644 (file)
@@ -243,7 +243,7 @@ Int_t AliHLTTRDCalibFitComponent::ShipDataToFXS(const AliHLTComponentEventData&
 
   HLTDebug("Size of the fOutArray is %d\n",fOutArray->GetEntriesFast());
 
-  PushToFXS((TObject*)fOutArray, "TRD", "GAINDRIFTPRF", rdList.Buffer() );
+  PushToFXS((TObject*)fOutArray, "TRD", "GAINDRIFTPRF", &rdList );
   //PushToFXS((TObject*)fOutArray->FindObject("CH2d"), "TRD", "GAINDRIFTPRF", rdList.Buffer() );
 
   return 0;
index f9612a1..8570723 100644 (file)
@@ -461,7 +461,7 @@ Int_t AliHLTTRDCalibrationComponent::ShipDataToFXS(const AliHLTComponentEventDat
 
   HLTDebug("Size of the fOutArray is %d\n",fOutArray->GetEntriesFast());
 
-  PushToFXS((TObject*)fOutArray, "TRD", "GAINDRIFTPRF", rdList.Buffer() );
+  PushToFXS((TObject*)fOutArray, "TRD", "GAINDRIFTPRF", &rdList );
   //PushToFXS((TObject*)fOutArray->FindObject("CH2d"), "TRD", "GAINDRIFTPRF", rdList.Buffer() );
 
   return 0;
index bbed3c6..0f99a65 100644 (file)
@@ -367,7 +367,7 @@ Int_t AliHLTCOMPHuffmanAltroCalibComponent::ShipDataToFXS( const AliHLTComponent
 
   fHuffmanData->SetOCDBSpecifications(fOrigin, dataspec);
   static AliHLTReadoutList rdList(AliHLTReadoutList::kTPC);
-  PushToFXS( (TObject*) fHuffmanData, "TPC", "HuffmanData", rdList.Buffer() ) ;
+  PushToFXS( (TObject*) fHuffmanData, "TPC", "HuffmanData", &rdList ) ;
   
   return 0;
 } // Int_t AliHLTCOMPHuffmanAltroCalibComponent::ShipDataToFXS( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData ) {
index ed61fea..d3e6009 100644 (file)
@@ -34,6 +34,7 @@ using namespace std;
 
 #include "AliHLTEventSummaryProducerComponent.h"
 #include "AliHLTTPCEventStatistics.h"
+#include "AliRawDataHeader.h"
 
 #include <cerrno>
 
@@ -155,17 +156,8 @@ Int_t AliHLTEventSummaryProducerComponent::DoEvent( const AliHLTComponentEventDa
 void AliHLTEventSummaryProducerComponent::ProcessTriggerData( AliHLTComponentTriggerData& trigData ) {
   // see header file for class documentation
   
-  AliHLTEventTriggerData* trg = ( AliHLTEventTriggerData* ) trigData.fData;
-
-  AliHLTUInt64_t triggerClass = 0;
-
-  // ** Higher bits
-  triggerClass |= ( trg->fCommonHeader[6] & 0x3FFFF );
-  
-  triggerClass =  triggerClass << 32;
-  
-  // ** Lower bits
-  triggerClass |= trg->fCommonHeader[5] ;
-
+  const AliRawDataHeader* cdh = NULL;
+  if (AliHLTComponent::ExtractTriggerData(trigData, NULL, NULL, &cdh, NULL, true) != 0) return;
+  AliHLTUInt64_t triggerClass = cdh->GetTriggerClasses();
   fEventSummary->SetTriggerClass( triggerClass );
 }
index a41ee03..4aed004 100644 (file)
@@ -35,6 +35,7 @@ using namespace std;
 #include "AliHLTRunSummaryProducerComponent.h"
 #include "AliHLTEventSummary.h"
 #include "AliHLTDataTypes.h"
+#include "AliRawDataHeader.h"
 
 #include <cerrno>
 
@@ -166,17 +167,9 @@ void AliHLTRunSummaryProducerComponent::ProcessEventSummary( AliHLTEventSummary*
 void AliHLTRunSummaryProducerComponent::ProcessTriggerData( AliHLTComponentTriggerData& trigData ) {
   // see header file for class documentation
   
-  AliHLTEventTriggerData* trg = ( AliHLTEventTriggerData* ) trigData.fData;
-
-  AliHLTUInt64_t triggerClasses = 0;
-
-  // ** Higher bits
-  triggerClasses |= ( trg->fCommonHeader[6] & 0x3FFFF );
-  
-  triggerClasses =  triggerClasses << 32;
-
-  // ** Lower bits
-  triggerClasses |= trg->fCommonHeader[5] ;
+  const AliRawDataHeader* cdh = NULL;
+  if (AliHLTComponent::ExtractTriggerData(trigData, NULL, NULL, &cdh, NULL, true) != 0) return;
+  AliHLTUInt64_t triggerClasses = cdh->GetTriggerClasses();
 
   for ( Int_t ndx = 0; ndx < gkNCTPTriggerClasses; ndx ++ ) {
     
index 2235c46..e0e09d4 100644 (file)
@@ -142,8 +142,7 @@ int AliHLTTrigger::TriggerEvent(
   // mask the readout list according to the CTP trigger
   // if the classes have been initialized (mask non-zero)
   if (CTPData() != NULL and CTPData()->Mask() != 0x0) {
-    AliHLTEventDDL eventDDL = CTPData()->ReadoutList(*GetTriggerData());
-    AliHLTReadoutList ctpreadout(eventDDL);
+    AliHLTReadoutList ctpreadout = CTPData()->ReadoutList(*GetTriggerData());
     ctpreadout.Enable(AliHLTReadoutList::kHLT);
     readoutlist.AndEq(ctpreadout);
     result->ReadoutList(readoutlist); // override the readout list with the masked one.
index dca4893..25233e9 100644 (file)
@@ -197,7 +197,7 @@ class AliHLTTrigger : public AliHLTProcessor
    */
   void EnableDDLBit(Int_t ddlId)
   {
-    AliHLTComponent::SetDDLBit(fReadoutList, ddlId, kTRUE);
+    fReadoutList.EnableDDLBit(ddlId);
   }
 
   /**
@@ -206,7 +206,7 @@ class AliHLTTrigger : public AliHLTProcessor
    */
   void DisableDDLBit(Int_t ddlId)
   {
-    AliHLTComponent::SetDDLBit(fReadoutList, ddlId, kFALSE);
+    fReadoutList.DisableDDLBit(ddlId);
   }
   
   /**
@@ -216,7 +216,7 @@ class AliHLTTrigger : public AliHLTProcessor
    */
   void SetDDLBit(Int_t ddlId, Bool_t state)
   {
-    AliHLTComponent::SetDDLBit(fReadoutList, ddlId, state);
+    fReadoutList.SetDDLBit(ddlId, state);
   }
   
   /**