propagation of HLT global trigger decision to hltESD

- adding HLTOUT handler for global trigger decision data block
- including the GLOBAL-Trigger configuration into HLT simulation
- handling of GlobalTrigger object in the ESDManager (generic handling
  of non-TClonesArrays in ESD merging still to be imlemented)

diff --git a/HLT/rec/AliHLTEsdManagerImplementation.cxx b/HLT/rec/AliHLTEsdManagerImplementation.cxx
index b4ac8670c3b89e29469e6539a084cccc28576faa..d5db9271b09af929fa51f3b98a8f4081199ad8c9 100644 (file)
--- a/HLT/rec/AliHLTEsdManagerImplementation.cxx
+++ b/HLT/rec/AliHLTEsdManagerImplementation.cxx
@@ -651,6 +651,16 @@ int AliHLTEsdManagerImplementation::Merge(AliESDEvent* pTgt, AliESDEvent* pSrc)
   while ((pSrcObject=next())) {
     if(!pSrcObject->InheritsFrom("TCollection")){
       // simple objects
   while ((pSrcObject=next())) {
     if(!pSrcObject->InheritsFrom("TCollection")){
       // simple objects

+      if(pSrcObject->InheritsFrom("AliHLTTriggerDecision")){
+       TObject* pTgtObject=pTgt->GetList()->FindObject(name);
+       if (pTgtObject) {
+         pSrcObject->Copy(*pTgtObject);
+       } else {
+         pTgt->AddObject(pSrcObject->Clone());
+       }
+      } else {
+       // TODO: implement the handling of other objects, some kind of mapping
+      }

     } else if(pSrcObject->InheritsFrom("TClonesArray")){
       TClonesArray* pTClA=dynamic_cast<TClonesArray*>(pSrcObject);
       if (pTClA!=NULL && pTClA->GetEntriesFast()>0) {
     } else if(pSrcObject->InheritsFrom("TClonesArray")){
       TClonesArray* pTClA=dynamic_cast<TClonesArray*>(pSrcObject);
       if (pTClA!=NULL && pTClA->GetEntriesFast()>0) {

diff --git a/HLT/trigger/AliHLTTriggerAgent.cxx b/HLT/trigger/AliHLTTriggerAgent.cxx
index 0e52934d7c913303fe3c8980ab6983e74dfbccdd..0320647a280eb71b7ddc5191b61123a81420a340 100644 (file)
--- a/HLT/trigger/AliHLTTriggerAgent.cxx
+++ b/HLT/trigger/AliHLTTriggerAgent.cxx
@@ -24,8 +24,13 @@
 
 #include <cassert>
 #include "AliHLTTriggerAgent.h"
 
 #include <cassert>
 #include "AliHLTTriggerAgent.h"

+#include "AliHLTTriggerDecision.h"
+#include "AliHLTOUT.h"
+#include "AliHLTMessage.h"
+#include "AliESDEvent.h"

 #include "TObjString.h"
 #include "TObjArray.h"
 #include "TObjString.h"
 #include "TObjArray.h"

+#include "TArrayC.h"

 
 // header files of library components
 #include "AliHLTEventSummaryProducerComponent.h"
 
 // header files of library components
 #include "AliHLTEventSummaryProducerComponent.h"


@@ -41,8 +46,8 @@ AliHLTTriggerAgent gAliHLTTriggerAgent;
 ClassImp(AliHLTTriggerAgent)
 
 AliHLTTriggerAgent::AliHLTTriggerAgent()
 ClassImp(AliHLTTriggerAgent)
 
 AliHLTTriggerAgent::AliHLTTriggerAgent()

-  :
-  AliHLTModuleAgent("Trigger")
+  : AliHLTModuleAgent("Trigger")
+  , fTriggerDecisionHandler(NULL)

 {
   // see header file for class documentation
   // or
 {
   // see header file for class documentation
   // or


@@ -128,7 +133,7 @@ const char* AliHLTTriggerAgent::GetReconstructionChains(AliRawReader* /*rawReade
     // AliRoot simulation
 
     // currently disabled due to a problem compiling the runtime trigger library
     // AliRoot simulation
 
     // currently disabled due to a problem compiling the runtime trigger library

-    //return "GLOBAL-Trigger";
+    return "GLOBAL-Trigger";

   }
   return NULL;
 }
   }
   return NULL;
 }


@@ -146,6 +151,17 @@ int AliHLTTriggerAgent::GetHandlerDescription(AliHLTComponentDataType dt,
 {
   // see header file for class documentation
 
 {
   // see header file for class documentation
 

+  // handler of the trigger decisions {'ROOTTOBJ':'HLT '}
+  // currently stored as a TObject with the common data type and origin
+  // HLTOUT. However we might need a separate data type in order to
+  // avoid interference with other handlers
+  // the handler produces an ESD object in order to be merged to the
+  // hltEsd afterwards
+  if (dt==(kAliHLTDataTypeTObject|kAliHLTDataOriginOut)) {
+    desc=AliHLTOUTHandlerDesc(AliHLTModuleAgent::kEsd, dt, GetModuleId());
+    return 1;
+  }
+

   // handler for the HLT readou list and trigger data data blocks {'HLTRDLST':'HLT '}
   if (dt==AliHLTComponentDataTypeInitializer("HLTRDLST", kAliHLTDataOriginOut) ||
       dt==AliHLTComponentDataTypeInitializer("HLTTRGDT", kAliHLTDataOriginOut)) {
   // handler for the HLT readou list and trigger data data blocks {'HLTRDLST':'HLT '}
   if (dt==AliHLTComponentDataTypeInitializer("HLTRDLST", kAliHLTDataOriginOut) ||
       dt==AliHLTComponentDataTypeInitializer("HLTTRGDT", kAliHLTDataOriginOut)) {


@@ -157,10 +173,18 @@ int AliHLTTriggerAgent::GetHandlerDescription(AliHLTComponentDataType dt,
 }
 
 AliHLTOUTHandler* AliHLTTriggerAgent::GetOutputHandler(AliHLTComponentDataType dt,
 }
 
 AliHLTOUTHandler* AliHLTTriggerAgent::GetOutputHandler(AliHLTComponentDataType dt,

-                                                  AliHLTUInt32_t /*spec*/)
+                                                      AliHLTUInt32_t /*spec*/)

 {
   // see header file for class documentation
 
 {
   // see header file for class documentation
 

+  // raw data blocks to be fed into offline reconstruction
+  if (dt==(kAliHLTDataTypeTObject|kAliHLTDataOriginOut)) {
+    if (!fTriggerDecisionHandler) {
+      fTriggerDecisionHandler=new AliHLTTriggerAgent::AliHLTTriggerDecisionHandler;
+    }
+    return fTriggerDecisionHandler;
+  }
+

   // handler for the HLT readou list and trigger data data blocks {'HLTRDLST':'HLT '}
   if (dt==AliHLTComponentDataTypeInitializer("HLTRDLST", kAliHLTDataOriginOut) ||
       dt==AliHLTComponentDataTypeInitializer("HLTTRGDT", kAliHLTDataOriginOut)) {
   // handler for the HLT readou list and trigger data data blocks {'HLTRDLST':'HLT '}
   if (dt==AliHLTComponentDataTypeInitializer("HLTRDLST", kAliHLTDataOriginOut) ||
       dt==AliHLTComponentDataTypeInitializer("HLTTRGDT", kAliHLTDataOriginOut)) {


@@ -175,5 +199,106 @@ int AliHLTTriggerAgent::DeleteOutputHandler(AliHLTOUTHandler* pInstance)
   // see header file for class documentation
   if (pInstance==NULL) return -EINVAL;
 
   // see header file for class documentation
   if (pInstance==NULL) return -EINVAL;
 

+  if (pInstance==fTriggerDecisionHandler) {
+    delete fTriggerDecisionHandler;
+    fTriggerDecisionHandler=NULL;
+  }
+

   return 0;
 }
   return 0;
 }

+
+AliHLTTriggerAgent::AliHLTTriggerDecisionHandler::AliHLTTriggerDecisionHandler()
+  : AliHLTOUTHandler() 
+  , fESD(NULL)
+  , fpData(NULL)
+  , fSize(0)
+{
+  // see header file for class documentation
+}
+
+AliHLTTriggerAgent::AliHLTTriggerDecisionHandler::~AliHLTTriggerDecisionHandler()
+{
+  // see header file for class documentation
+  if (fESD) delete fESD;
+  fESD=NULL;
+
+  if (fpData) delete fpData;
+  fpData=NULL;
+  fSize=0;
+}
+
+int AliHLTTriggerAgent::AliHLTTriggerDecisionHandler::ProcessData(AliHLTOUT* pData)
+{
+  // see header file for class documentation
+  if (!pData) return -EINVAL;
+  AliHLTComponentDataType dt=kAliHLTVoidDataType;
+  AliHLTUInt32_t spec=kAliHLTVoidDataSpec;
+  int iResult=pData->GetDataBlockDescription(dt, spec);
+  if (iResult>=0) {
+    TObject* pObject=pData->GetDataObject();
+    if (pObject) {
+      AliHLTTriggerDecision* pDecission=dynamic_cast<AliHLTTriggerDecision*>(pObject);
+      if (pDecission) {
+       if (!fESD) {
+         // create the ESD container, but without std content
+         fESD = new AliESDEvent;
+       }
+       if (!fpData) fpData=new TArrayC;
+       if (fESD && fpData) {
+         fESD->Reset();
+         fESD->AddObject(pObject->Clone());
+         AliHLTMessage* pMsg=AliHLTMessage::Stream(fESD);
+         if (pMsg) {
+           if (!pMsg->CompBuffer()) {
+             fSize=pMsg->Length();
+             fpData->Set(fSize, pMsg->Buffer());
+           } else {
+             fSize=pMsg->CompLength();
+             fpData->Set(fSize, pMsg->CompBuffer());
+           }
+         } else {
+           HLTError("streaming of objects failed");
+         }
+       } else {
+         HLTError("memory allocation failed");
+         iResult=-ENOMEM;
+       }
+      } else {
+       HLTError("object %s is not an AliHLTTriggerDecision", pObject->GetName());
+       iResult=-ENODATA;
+      }
+      pData->ReleaseDataObject(pObject);
+      pObject=NULL;
+    } else {
+      HLTError("can not get TObject from HLTOUT buffer");
+      iResult=-ENODATA;
+    }
+  }
+  if (iResult>=0) return fSize;
+  fSize=0;
+  return iResult;
+}
+
+int AliHLTTriggerAgent::AliHLTTriggerDecisionHandler::GetProcessedData(const AliHLTUInt8_t* &pData)
+{
+  // see header file for class documentation
+  if (!fpData) {
+    pData=NULL;
+    return 0;
+  }
+
+  pData=reinterpret_cast<AliHLTUInt8_t*>(fpData->GetArray());
+  return fSize;
+}
+
+int AliHLTTriggerAgent::AliHLTTriggerDecisionHandler::ReleaseProcessedData(const AliHLTUInt8_t* pData, int size)
+{
+  // see header file for class documentation
+  int iResult=0;
+  if (!fpData || size != fSize ||
+      const_cast<AliHLTUInt8_t*>(pData) != reinterpret_cast<AliHLTUInt8_t*>(fpData->GetArray())) {
+    HLTError("attempt to release to wrong data buffer %p size %d, expected %p size %d", pData, size, fpData?fpData->GetArray():NULL, fSize);
+  }
+  fSize=0;
+  return iResult;
+}

diff --git a/HLT/trigger/AliHLTTriggerAgent.h b/HLT/trigger/AliHLTTriggerAgent.h
index 9034b8b289a351eea503a564d9fb1d820f79a308..87412023dc45ff1400bfb3ac5c5008d3f5003553 100644 (file)
--- a/HLT/trigger/AliHLTTriggerAgent.h
+++ b/HLT/trigger/AliHLTTriggerAgent.h
@@ -13,8 +13,10 @@
 */
 
 #include "AliHLTModuleAgent.h"
 */
 
 #include "AliHLTModuleAgent.h"

+#include "AliHLTOUTHandler.h"

 
 

-class AliHLTOUTHandler;
+class AliESDEvent;
+class TArrayC;

 
 /**
  * @class AliHLTTriggerAgent
 
 /**
  * @class AliHLTTriggerAgent


@@ -78,6 +80,35 @@ class AliHLTTriggerAgent : public AliHLTModuleAgent {
 
   int DeleteOutputHandler(AliHLTOUTHandler* pInstance);
 
 
   int DeleteOutputHandler(AliHLTOUTHandler* pInstance);
 

+  /**
+   * The handler for trigger decision blocks in the HLTOUT stream.
+   */
+  class AliHLTTriggerDecisionHandler : public AliHLTOUTHandler {
+  public:
+    /** constructor */
+    AliHLTTriggerDecisionHandler();
+    /** destructor */
+    ~AliHLTTriggerDecisionHandler();
+
+    /**
+     * Process a data block.
+     * Decode specification and return equipment id of the data block.
+     * The data itsself i untouched.
+     * @return equipment id the block should be used for.
+     */
+    int ProcessData(AliHLTOUT* pData);
+
+    /** inherited from AliHLTOUTHandler */
+    int GetProcessedData(const AliHLTUInt8_t* &pData);
+
+    /** inherited from AliHLTOUTHandler */
+    int ReleaseProcessedData(const AliHLTUInt8_t* pData, int size);
+
+  private:
+    AliESDEvent* fESD; //!
+    TArrayC* fpData;  //!
+    int fSize; //!
+  };

  protected:
 
  private:
  protected:
 
  private:


@@ -86,7 +117,10 @@ class AliHLTTriggerAgent : public AliHLTModuleAgent {
   /** assignment operator prohibited */
   AliHLTTriggerAgent& operator=(const AliHLTTriggerAgent&);
 
   /** assignment operator prohibited */
   AliHLTTriggerAgent& operator=(const AliHLTTriggerAgent&);
 

-  ClassDef(AliHLTTriggerAgent, 0);
+  /** handler for trigger decision blocks */
+  AliHLTTriggerDecisionHandler* fTriggerDecisionHandler; //!
+
+  ClassDef(AliHLTTriggerAgent, 1);

 };
 
 #endif
 };
 
 #endif