Changes required to handle software triggers correctly in the global trigger component.
[u/mrichter/AliRoot.git] / HLT / BASE / AliHLTComponent.cxx
index bd26d4d..46ab071 100644 (file)
 //* provided "as is" without express or implied warranty.                  *
 //**************************************************************************
 
-/** @file   AliHLTComponent.cxx
-    @author Matthias Richter, Timm Steinbeck
-    @date   
-    @brief  Base class implementation for HLT components. */
+//  @file   AliHLTComponent.cxx
+//  @author Matthias Richter, Timm Steinbeck
+//  @date   
+//  @brief  Base class implementation for HLT components. */
+//  @note   The class is both used in Online (PubSub) and Offline (AliRoot)
+//          context
+
 
 #if __GNUC__>= 3
 using namespace std;
@@ -31,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"
@@ -38,6 +42,9 @@ using namespace std;
 #include "TClass.h"
 #include "TStopwatch.h"
 #include "TFormula.h"
+#include "TUUID.h"
+#include "TMD5.h"
+#include "TRandom3.h"
 #include "AliHLTMemoryFile.h"
 #include "AliHLTMisc.h"
 #include <cassert>
@@ -81,12 +88,11 @@ AliHLTComponent::AliHLTComponent()
   fpStopwatches(new TObjArray(kSWTypeCount)),
   fMemFiles(),
   fpRunDesc(NULL),
-  fpDDLList(NULL),
   fCDBSetRunNoFunc(false),
   fChainId(),
   fChainIdCrc(0),
   fpBenchmark(NULL),
-  fRequireSteeringBlocks(false),
+  fFlags(0),
   fEventType(gkAliEventTypeUnknown),
   fComponentArgs(),
   fEventDoneData(NULL),
@@ -238,6 +244,9 @@ int AliHLTComponent::Init(const AliHLTAnalysisEnvironment* comenv, void* environ
          } else {
            HLTError("wrong parameter for argument -pushback-period, number expected");
          }
+         // -disable-component-stat
+       } else if (argument.CompareTo("-disable-component-stat")==0) {
+         fFlags|=kDisableComponentStat;
        } else {
          pArguments[iNofChildArgs++]=argv[i];
        }
@@ -251,6 +260,9 @@ int AliHLTComponent::Init(const AliHLTAnalysisEnvironment* comenv, void* environ
     iResult=-EINVAL;
   }
   if (iResult>=0) {
+    iResult=CheckOCDBEntries();
+  }
+  if (iResult>=0) {
     iResult=DoInit(iNofChildArgs, pArguments);
   }
   if (iResult>=0) {
@@ -260,22 +272,24 @@ int AliHLTComponent::Init(const AliHLTAnalysisEnvironment* comenv, void* environ
     // explicitly
     AliHLTComponentDataTypeList inputDt;
     GetInputDataTypes(inputDt);
+    bool bRequireSteeringBlocks=false;
     for (AliHLTComponentDataTypeList::iterator dt=inputDt.begin();
-        dt!=inputDt.end() && !fRequireSteeringBlocks;
+        dt!=inputDt.end() && !bRequireSteeringBlocks;
         dt++) {
-      fRequireSteeringBlocks|=MatchExactly(*dt,kAliHLTDataTypeSOR);
-      fRequireSteeringBlocks|=MatchExactly(*dt,kAliHLTDataTypeRunType);
-      fRequireSteeringBlocks|=MatchExactly(*dt,kAliHLTDataTypeEOR);
-      fRequireSteeringBlocks|=MatchExactly(*dt,kAliHLTDataTypeDDL);
-      fRequireSteeringBlocks|=MatchExactly(*dt,kAliHLTDataTypeComponentStatistics);
+      bRequireSteeringBlocks|=MatchExactly(*dt,kAliHLTDataTypeSOR);
+      bRequireSteeringBlocks|=MatchExactly(*dt,kAliHLTDataTypeRunType);
+      bRequireSteeringBlocks|=MatchExactly(*dt,kAliHLTDataTypeEOR);
+      bRequireSteeringBlocks|=MatchExactly(*dt,kAliHLTDataTypeDDL);
+      bRequireSteeringBlocks|=MatchExactly(*dt,kAliHLTDataTypeComponentStatistics);
     }
+    if (bRequireSteeringBlocks) fFlags|=kRequireSteeringBlocks;
   }
   if (pArguments) delete [] pArguments;
 
-#if defined(__DEBUG) || defined(HLT_COMPONENT_STATISTICS)
+#if defined(HLT_COMPONENT_STATISTICS)
   // benchmarking stopwatch for the component statistics
   fpBenchmark=new TStopwatch;
-#endif
+#endif // HLT_COMPONENT_STATISTICS
 
   return iResult;
 }
@@ -304,6 +318,7 @@ int AliHLTComponent::Deinit()
   fpCTPData=NULL;
 
   fEventCount=0;
+  fFlags=0;
   return iResult;
 }
 
@@ -406,6 +421,7 @@ int AliHLTComponent::SetComponentDescription(const char* desc)
        HLTWarning("unknown component description %s", argument.Data());
       }
     }
+    delete pTokens;
   }
   
   return iResult;
@@ -421,7 +437,35 @@ int AliHLTComponent::ConfigureFromArgumentString(int argc, const char** argv)
   int i=0;
   for (i=0; i<argc && iResult>=0; i++) {
     argument=argv[i];
+    if (argument.IsWhitespace()) continue;
+
+    // special handling for single component arguments ending with
+    // a sequence of blanks
+    argument.Remove(0, argument.First(' '));
+    if (argument.IsWhitespace()) {
+      array.push_back(argv[i]);
+      continue;
+    }
+
+    // extra blank to insert blank token before leading quotes
+    argument=" ";
+    argument+=argv[i];
+    // insert blank in consecutive quotes to correctly tokenize
+    argument.ReplaceAll("''", "' '");
+    // replace newlines by blanks
+    argument.ReplaceAll("\n", " ");
     if (argument.IsNull()) continue;
+    TObjArray* pTokensQuote=argument.Tokenize("'");
+    if (pTokensQuote) {
+      if (pTokensQuote->GetEntriesFast()>0) {
+       for (int k=0; k<pTokensQuote->GetEntriesFast(); k++) {
+         argument=((TObjString*)pTokensQuote->At(k))->GetString();
+         if (argument.IsWhitespace()) continue;
+         if (k%2) {
+           // every second entry is enclosed by quotes and thus
+           // one single argument
+           array.push_back(argument.Data());
+         } else {
     TObjArray* pTokens=argument.Tokenize(" ");
     if (pTokens) {
       if (pTokens->GetEntriesFast()>0) {
@@ -436,6 +480,12 @@ int AliHLTComponent::ConfigureFromArgumentString(int argc, const char** argv)
       }
       delete pTokens;
     }
+         }
+       }
+       pTokensQuote->SetOwner(kFALSE);
+      }
+      delete pTokensQuote;
+    }
   }
 
   for (i=0; (unsigned)i<array.size() && iResult>=0;) {
@@ -460,9 +510,10 @@ int AliHLTComponent::ConfigureFromArgumentString(int argc, const char** argv)
   return iResult;
 }
 
-int AliHLTComponent::ConfigureFromCDBTObjString(const char* entries)
+int AliHLTComponent::ConfigureFromCDBTObjString(const char* entries, const char* key)
 {
-  // see header file for function documentation
+  // load a list of OCDB objects and configure from the objects
+  // can either be a TObjString or a TMap with a TObjString:TObjString key-value pair
   int iResult=0;
   TString arguments;
   TString confEntries=entries;
@@ -471,16 +522,32 @@ int AliHLTComponent::ConfigureFromCDBTObjString(const char* entries)
     for (int n=0; n<pTokens->GetEntriesFast(); n++) {
       const char* path=((TObjString*)pTokens->At(n))->GetString().Data();
       const char* chainId=GetChainId();
-      HLTInfo("configure from entry %s, chain id %s", path, (chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
-      TObject* pOCDBObject = LoadAndExtractOCDBObject(path);
+      HLTInfo("configure from entry \"%s\"%s%s, chain id %s", path, key?" key ":"",key?key:"", (chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
+      TObject* pOCDBObject = LoadAndExtractOCDBObject(path, key);
       if (pOCDBObject) {
        TObjString* pString=dynamic_cast<TObjString*>(pOCDBObject);
+       if (!pString) {
+         TMap* pMap=dynamic_cast<TMap*>(pOCDBObject);
+         if (pMap) {
+           // this is the case where no key has been specified and the OCDB
+           // object is a TMap, search for the default key
+           TObject* pObject=pMap->GetValue("default");
+           if (pObject && (pString=dynamic_cast<TObjString*>(pObject))!=NULL) {
+             HLTInfo("using default key of TMap of configuration object \"%s\"", path);
+           } else {
+             HLTError("no default key available in TMap of configuration object \"%s\"", path);
+             iResult=-ENOENT;
+             break;
+           }
+         }
+       }
+
        if (pString) {
          HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
          arguments+=pString->GetString().Data();
          arguments+=" ";
        } else {
-         HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
+         HLTError("configuration object \"%s\"%s%s has wrong type, required TObjString", path, key?" key ":"",key?key:"");
          iResult=-EINVAL;
        }
       } else {
@@ -497,12 +564,27 @@ int AliHLTComponent::ConfigureFromCDBTObjString(const char* entries)
   return iResult;
 }
 
-TObject* AliHLTComponent::LoadAndExtractOCDBObject(const char* path, int version, int subVersion)
+TObject* AliHLTComponent::LoadAndExtractOCDBObject(const char* path, int version, int subVersion, const char* key)
 {
   // see header file for function documentation
   AliCDBEntry* pEntry=AliHLTMisc::Instance().LoadOCDBEntry(path, GetRunNo(), version, subVersion);
   if (!pEntry) return NULL;
-  return AliHLTMisc::Instance().ExtractObject(pEntry);
+  TObject* pObject=AliHLTMisc::Instance().ExtractObject(pEntry);
+  TMap* pMap=dynamic_cast<TMap*>(pObject);
+  if (pMap && key) {
+    pObject=pMap->GetValue(key);
+    if (!pObject) {
+      pObject=pMap->GetValue("default");
+      if (pObject) {
+       HLTWarning("can not find object for key \"%s\" in TMap of configuration object \"%s\", using key \"default\"", key, path);
+      }
+    }
+    if (!pObject) {
+      HLTError("can not find object for key \"%s\" in TMap of configuration object \"%s\"", key, path);
+      return NULL;
+    }
+  }
+  return pObject;
 }
 
 int AliHLTComponent::DoInit( int /*argc*/, const char** /*argv*/)
@@ -563,6 +645,36 @@ int AliHLTComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& /*tgtList*/
   return 0;
 }
 
+void AliHLTComponent::GetOCDBObjectDescription( TMap* const /*targetArray*/)
+{
+  // default implementation, childs can overload
+  HLTLogKeyword("dummy");
+}
+
+int AliHLTComponent::CheckOCDBEntries(const TMap* const externList)
+{
+  // check the availability of the OCDB entry descriptions in the TMap
+  //  key : complete OCDB path of the entry
+  //  value : auxiliary object - short description
+  // if the external map was not provided the function invokes
+  // interface function GetOCDBObjectDescription() to retrieve the list.
+  int iResult=0;
+  if (externList) {
+    iResult=AliHLTMisc::Instance().CheckOCDBEntries(externList);
+  } else {
+    TMap* pMap=new TMap;
+    if (pMap) {
+      pMap->SetOwnerKeyValue(kTRUE);
+      GetOCDBObjectDescription(pMap);
+      iResult=AliHLTMisc::Instance().CheckOCDBEntries(pMap);
+      delete pMap;
+      pMap=NULL;
+    }
+  }
+
+  return iResult;
+}
+
 void AliHLTComponent::DataType2Text( const AliHLTComponentDataType& type, char output[kAliHLTComponentDataTypefIDsize+kAliHLTComponentDataTypefOriginSize+2] ) const
 {
   // see header file for function documentation
@@ -577,6 +689,39 @@ string AliHLTComponent::DataType2Text( const AliHLTComponentDataType& type, int
   // see header file for function documentation
   string out("");
 
+  // 'typeid' 'origin'
+  // aligned to 8 and 4 chars respectively, blocks enclosed in quotes and
+  // separated by blank e.g.
+  // 'DDL_RAW ' 'TPC '
+  if (mode==3) {
+    int i=0;
+    char tmp[8];
+    out+="'";
+    for (i=0; i<kAliHLTComponentDataTypefIDsize; i++) {
+      unsigned char* puc=(unsigned char*)type.fID;
+      if (puc[i]<32)
+       sprintf(tmp, "\\%x", type.fID[i]);
+      else
+       sprintf(tmp, "%c", type.fID[i]);
+      out+=tmp;
+    }
+    out+="' '";
+    for (i=0; i<kAliHLTComponentDataTypefOriginSize; i++) {
+      unsigned char* puc=(unsigned char*)type.fOrigin;
+      if ((puc[i])<32)
+       sprintf(tmp, "\\%x", type.fOrigin[i]);
+      else
+       sprintf(tmp, "%c", type.fOrigin[i]);
+      out+=tmp;
+    }
+    out+="'";
+    return out;
+  }
+
+  // origin typeid as numbers separated by colon e.g.
+  // aligned to 8 and 4 chars respectively, all characters separated by
+  // quotes, e.g.
+  // '84'80'67'32':'68'68'76'95'82'65'87'32'
   if (mode==2) {
     int i=0;
     char tmp[8];
@@ -592,6 +737,10 @@ string AliHLTComponent::DataType2Text( const AliHLTComponentDataType& type, int
     return out;
   }
 
+  // origin typeid separated by colon e.g.
+  // aligned to 8 and 4 chars respectively, all characters separated by
+  // quotes, e.g.
+  // 'T'P'C' ':'D'D'L'_'R'A'W' '
   if (mode==1) {
     int i=0;
     char tmp[8];
@@ -615,6 +764,9 @@ string AliHLTComponent::DataType2Text( const AliHLTComponentDataType& type, int
     return out;
   }
 
+  // origin typeid
+  // aligned to 8 and 4 chars respectively, separated by colon e.g.
+  // TPC :DDL_RAW 
   if (type==kAliHLTVoidDataType) {
     out="VOID:VOID";
   } else {
@@ -677,7 +829,7 @@ int AliHLTComponent::MakeOutputDataBlockList( const AliHLTComponentBlockDataList
 
 }
 
-int AliHLTComponent::GetEventDoneData( unsigned long size, AliHLTComponentEventDoneData** edd ) 
+int AliHLTComponent::GetEventDoneData( unsigned long size, AliHLTComponentEventDoneData** edd ) const
 {
   // see header file for function documentation
   if (fEnvironment.fGetEventDoneDataFunc)
@@ -714,6 +866,7 @@ int AliHLTComponent::ReserveEventDoneData( unsigned long size )
 
 int AliHLTComponent::PushEventDoneData( AliHLTUInt32_t eddDataWord )
 {
+  // see header file for function documentation
   if (!fEventDoneData)
     return -ENOMEM;
   if (fEventDoneData->fDataSize+sizeof(AliHLTUInt32_t)>fEventDoneDataSize)
@@ -725,7 +878,8 @@ int AliHLTComponent::PushEventDoneData( AliHLTUInt32_t eddDataWord )
 
 void AliHLTComponent::ReleaseEventDoneData()
 {
-  if (fEventDoneData)
+   // see header file for function documentation
+ if (fEventDoneData)
     delete [] reinterpret_cast<AliHLTUInt8_t*>( fEventDoneData );
   fEventDoneData = NULL;
   fEventDoneDataSize = 0;
@@ -748,7 +902,7 @@ int AliHLTComponent::FindMatchingDataTypes(AliHLTComponent* pConsumer, AliHLTCom
        HLTWarning("component %s indicates multiple output data types but GetOutputDataTypes returns %d", GetComponentID(), count);
       }
     }
-    ((AliHLTComponent*)pConsumer)->GetInputDataTypes(itypes);
+    pConsumer->GetInputDataTypes(itypes);
     AliHLTComponentDataTypeList::iterator otype=otypes.begin();
     for (;otype!=otypes.end();otype++) {
       //PrintDataTypeContent((*otype), "publisher \'%s\'");
@@ -1127,7 +1281,7 @@ int AliHLTComponent::Forward(const AliHLTComponentBlockData* pBlock)
   int iResult=0;
   int idx=fCurrentInputBlock;
   if (pBlock) {
-    if (fpInputObjects==NULL || (idx=FindInputBlock(pBlock))>=0) {
+    if ((idx=FindInputBlock(pBlock))>=0) {
     } else {
       HLTError("unknown Block %p", pBlock);
       iResult=-ENOENT;      
@@ -1363,10 +1517,11 @@ int AliHLTComponent::InsertOutputBlock(const void* pBuffer, int iBufferSize, con
 int AliHLTComponent::EstimateObjectSize(TObject* pObject) const
 {
   // see header file for function documentation
-  if (!pObject) return -EINVAL;
-    AliHLTMessage msg(kMESS_OBJECT);
-    msg.WriteObject(pObject);
-    return msg.Length();  
+  if (!pObject) return 0;
+
+  AliHLTMessage msg(kMESS_OBJECT);
+  msg.WriteObject(pObject);
+  return msg.Length();  
 }
 
 AliHLTMemoryFile* AliHLTComponent::CreateMemoryFile(int capacity, const char* dtID,
@@ -1569,19 +1724,21 @@ int AliHLTComponent::ProcessEvent( const AliHLTComponentEventData& evtData,
   AliHLTComponentStatisticsList compStats;
   bool bAddComponentTableEntry=false;
   vector<AliHLTUInt32_t> parentComponentTables;
-#if defined(__DEBUG) || defined(HLT_COMPONENT_STATISTICS)
-  AliHLTComponentStatistics outputStat;
-  memset(&outputStat, 0, sizeof(AliHLTComponentStatistics));
-  outputStat.fStructSize=sizeof(AliHLTComponentStatistics);
-  outputStat.fId=fChainIdCrc;
-  if (fpBenchmark) {
-    fpBenchmark->Stop();
-    outputStat.fComponentCycleTime=(AliHLTUInt32_t)(fpBenchmark->RealTime()*ALIHLTCOMPONENT_STATTIME_SCALER);
-    fpBenchmark->Reset();
-    fpBenchmark->Start();
+#if defined(HLT_COMPONENT_STATISTICS)
+  if ((fFlags&kDisableComponentStat)==0) {
+    AliHLTComponentStatistics outputStat;
+    memset(&outputStat, 0, sizeof(AliHLTComponentStatistics));
+    outputStat.fStructSize=sizeof(AliHLTComponentStatistics);
+    outputStat.fId=fChainIdCrc;
+    if (fpBenchmark) {
+      fpBenchmark->Stop();
+      outputStat.fComponentCycleTime=(AliHLTUInt32_t)(fpBenchmark->RealTime()*ALIHLTCOMPONENT_STATTIME_SCALER);
+      fpBenchmark->Reset();
+      fpBenchmark->Start();
+    }
+    compStats.push_back(outputStat);
   }
-  compStats.push_back(outputStat);
-#endif
+#endif // HLT_COMPONENT_STATISTICS
 
   // data processing is skipped
   // -  if there are only steering events in the block list.
@@ -1628,6 +1785,18 @@ int AliHLTComponent::ProcessEvent( const AliHLTComponentEventData& evtData,
        indexUpdtDCSEvent=i;
       } else if (fpInputBlocks[i].fDataType==kAliHLTDataTypeEvent) {
        fEventType=fpInputBlocks[i].fSpecification;
+       if (fEventType != gkAliEventTypeConfiguration and
+           fEventType != gkAliEventTypeReadPreprocessor
+          )
+       {
+         // 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;
+         if (ExtractTriggerData(trigData, NULL, NULL, &cdh, NULL) == 0)
+         {
+           fEventType = ExtractEventTypeFromCDH(cdh);
+         }
+       }
 
        // skip always in case of gkAliEventTypeConfiguration
        if (fpInputBlocks[i].fSpecification==gkAliEventTypeConfiguration) bSkipDataProcessing|=skipModeForce;
@@ -1762,7 +1931,7 @@ int AliHLTComponent::ProcessEvent( const AliHLTComponentEventData& evtData,
 
   // data processing is not skipped if the component explicitly asks
   // for the private blocks
-  if (fRequireSteeringBlocks) bSkipDataProcessing=0;
+  if ((fFlags&kRequireSteeringBlocks)!=0) bSkipDataProcessing=0;
 
   if (fpCTPData) {
     // set the active triggers for this event
@@ -1876,7 +2045,8 @@ int  AliHLTComponent::AddComponentStatistics(AliHLTComponentBlockDataList& block
 {
   // see header file for function documentation
   int iResult=0;
-#if defined(__DEBUG) || defined(HLT_COMPONENT_STATISTICS)
+  if ((fFlags&kDisableComponentStat)!=0) return 0;
+#if defined(HLT_COMPONENT_STATISTICS)
   if (stats.size()==0) return -ENOENT;
   // check if there is space for at least one entry
   if (offset+sizeof(AliHLTComponentStatistics)>bufferSize) return 0;
@@ -1942,7 +2112,7 @@ int  AliHLTComponent::AddComponentStatistics(AliHLTComponentBlockDataList& block
   if (blocks.size() && buffer && bufferSize && offset && stats.size()) {
     // get rid of warning
   }
-#endif
+#endif // HLT_COMPONENT_STATISTICS
   return iResult;
 }
 
@@ -1954,7 +2124,8 @@ int  AliHLTComponent::AddComponentTableEntry(AliHLTComponentBlockDataList& block
 {
   // see header file for function documentation
   int iResult=0;
-#if defined(__DEBUG) || defined(HLT_COMPONENT_STATISTICS)
+  if ((fFlags&kDisableComponentStat)!=0) return 0;
+#if defined(HLT_COMPONENT_STATISTICS)
   // the payload consists of the AliHLTComponentTableEntry struct,
   // followed by a an array of 32bit crc chain ids and the component
   // description string
@@ -2014,7 +2185,7 @@ int  AliHLTComponent::AddComponentTableEntry(AliHLTComponentBlockDataList& block
   if (blocks.size() && buffer && bufferSize && offset && parents.size()) {
     // get rid of warning
   }
- #endif
+#endif // HLT_COMPONENT_STATISTICS
   return iResult;
 }
 
@@ -2082,14 +2253,14 @@ AliHLTComponent::AliHLTStopwatchGuard::~AliHLTStopwatchGuard()
   fgpCurrent=fpPrec;
 }
 
-int AliHLTComponent::AliHLTStopwatchGuard::Hold(TStopwatch* pSucc)
+int AliHLTComponent::AliHLTStopwatchGuard::Hold(const TStopwatch* pSucc)
 {
   // see header file for function documentation
   if (fpStopwatch!=NULL && fpStopwatch!=pSucc) fpStopwatch->Stop();
   return fpStopwatch!=pSucc?1:0;
 }
 
-int AliHLTComponent::AliHLTStopwatchGuard::Resume(TStopwatch* pSucc)
+int AliHLTComponent::AliHLTStopwatchGuard::Resume(const TStopwatch* pSucc)
 {
   // see header file for function documentation
   if (fpStopwatch!=NULL && fpStopwatch!=pSucc) fpStopwatch->Start(kFALSE);
@@ -2181,13 +2352,12 @@ AliHLTUInt16_t    AliHLTComponent::GetBunchCrossNumber() const
   return GetEventId()&0xfff;
 }
 
-bool AliHLTComponent::IsDataEvent(AliHLTUInt32_t* pTgt)
+bool AliHLTComponent::IsDataEvent(AliHLTUInt32_t* pTgt) const
 {
   // see header file for function documentation
   if (pTgt) *pTgt=fEventType;
   return (fEventType==gkAliEventTypeData ||
-         fEventType==gkAliEventTypeDataReplay ||
-         fEventType==gkAliEventTypeCalibration);
+         fEventType==gkAliEventTypeDataReplay);
 }
 
 int AliHLTComponent::CopyStruct(void* pStruct, unsigned int iStructSize, unsigned int iBlockNo,
@@ -2228,73 +2398,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
@@ -2405,6 +2508,121 @@ 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;
+  }
+  
+  // Get the size of the AliHLTEventTriggerData structure without the readout list part.
+  // The way we do this here should also handle memory alignment correctly.
+  AliHLTEventTriggerData* dummy = NULL;
+  size_t sizeWithoutReadout = (char*)(&dummy->fReadoutList) - (char*)(dummy);
+  
+  // Check that the trigger data pointer points to data of a size we can handle.
+  // Either it is the size of AliHLTEventTriggerData or the size of the old
+  // version of AliHLTEventTriggerData using AliHLTEventDDLV0.
+  if (trigData.fDataSize != sizeof(AliHLTEventTriggerData) and
+      trigData.fDataSize != sizeWithoutReadout + sizeof(AliHLTEventDDLV0)
+     )
+  {
+    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;
+}
+
+AliHLTUInt32_t AliHLTComponent::ExtractEventTypeFromCDH(const AliRawDataHeader* 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.
+  if (((l1msg >> 2) & 0xF) == 0xE) return gkAliEventTypeStartOfRun;
+  if (((l1msg >> 2) & 0xF) == 0xF) return gkAliEventTypeEndOfRun;
+  // Check the C1T bit to see if this is a calibration event,
+  // if not then it must be some other software trigger event.
+  if (((l1msg >> 6) & 0x1) == 0x1) return gkAliEventTypeCalibration;
+  return gkAliEventTypeSoftware;
+}
+
 int AliHLTComponent::LoggingVarargs(AliHLTComponentLogSeverity severity, 
                                    const char* originClass, const char* originFunc,
                                    const char* file, int line, ... ) const
@@ -2428,6 +2646,55 @@ int AliHLTComponent::LoggingVarargs(AliHLTComponentLogSeverity severity,
   return iResult;
 }
 
+TUUID AliHLTComponent::GenerateGUID()
+{
+  // Generates a globally unique identifier.
+
+  // Start by creating a new UUID. We cannot use the one automatically generated
+  // by ROOT because the algorithm used will not guarantee unique IDs when generating
+  // these UUIDs at a high rate in parallel.
+  TUUID uuid;
+  // We then use the generated UUID to form part of the random number seeds which
+  // will be used to generate a proper random UUID. For good measure we use a MD5
+  // hash also. Note that we want to use the TUUID class because it will combine the
+  // host address information into the UUID. Using gSystem->GetHostByName() apparently
+  // can cause problems on Windows machines with a firewall, because it always tries
+  // to contact a DNS. The TUUID class handles this case appropriately.
+  union
+  {
+    UChar_t buf[16];
+    UShort_t word[8];
+    UInt_t dword[4];
+  };
+  uuid.GetUUID(buf);
+  TMD5 md5;
+  md5.Update(buf, sizeof(buf));
+  TMD5 md52 = md5;
+  md5.Final(buf);
+  dword[0] += gSystem->GetUid();
+  dword[1] += gSystem->GetGid();
+  dword[2] += gSystem->GetPid();
+  for (int i = 0; i < 4; ++i)
+  {
+    gRandom->SetSeed(dword[i]);
+    dword[i] = gRandom->Integer(0xFFFFFFFF);
+  }
+  md52.Update(buf, sizeof(buf));
+  md52.Final(buf);
+  // To keep to the standard we need to set the version and reserved bits.
+  word[3] = (word[3] & 0x0FFF) | 0x4000;
+  buf[8] = (buf[8] & 0x3F) | 0x80;
+
+  // Create the name of the new class and file.
+  char uuidstr[64];
+  sprintf(uuidstr, "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+    dword[0], word[2], word[3], buf[8], buf[9], buf[10], buf[11], buf[12], buf[13], buf[14], buf[15]
+  );
+
+  uuid.SetUUID(uuidstr);
+  return uuid;
+}
+
 int AliHLTComponent::ScanECSParam(const char* ecsParam)
 {
   // see header file for function documentation
@@ -2502,6 +2769,19 @@ bool AliHLTComponent::EvaluateCTPTriggerClass(const char* expression, AliHLTComp
   return fpCTPData->EvaluateCTPTriggerClass(expression, trigData);
 }
 
+int AliHLTComponent::CheckCTPTrigger(const char* name) const
+{
+  // see header file for function documentation
+  if (!fpCTPData) {
+    static bool bWarningThrown=false;
+    if (!bWarningThrown) HLTError("Trigger classes not initialized, use SetupCTPData from DoInit()");
+    bWarningThrown=true;
+    return false;
+  }
+
+  return fpCTPData->CheckTrigger(name);
+}
+
 Double_t AliHLTComponent::GetBz()
 {
   // Returns Bz.