- adding TPC-mcTrackMarker configuration (propagation of MC information

  through the TPC reconstruction chain)
- removing the TPC-esd-converter from the default AliHLTSimulation chain
- adding global ESD converter to default AliHLTSimulation chain
    configuration: GLOBAL-esd-converter
    input: TPC-globalmerger TPC-mcTrackMarker
- correcting input type definition of TPCEsdWriter (avoid runtime warning)

diff --git a/HLT/TPCLib/AliHLTTPCAgent.cxx b/HLT/TPCLib/AliHLTTPCAgent.cxx
index 681715a8f6884d7a3adb4e95c29003646eb9cd80..0b63ad4122e9fcf6bc83bb067f15c6e833846131 100644 (file)
--- a/HLT/TPCLib/AliHLTTPCAgent.cxx
+++ b/HLT/TPCLib/AliHLTTPCAgent.cxx
@@ -176,8 +176,10 @@ int AliHLTTPCAgent::CreateConfigurations(AliHLTConfigurationHandler* handler,
     TString converterInput="TPC-globalmerger";
     if (!rawReader) {
       // propagate cluster info to the esd converter in order to fill the MC information
+      handler->CreateConfiguration("TPC-clustermc-info", "BlockFilter"   , sinkClusterInput.Data(), "-datatype 'CLMCINFO' 'TPC '");  
+      handler->CreateConfiguration("TPC-mcTrackMarker","TPCTrackMCMarker","TPC-globalmerger TPC-clustermc-info","" );
       converterInput+=" ";
-      converterInput+=sinkClusterInput;
+      converterInput+="TPC-mcTrackMarker";
     }
     handler->CreateConfiguration("TPC-esd-converter", "TPCEsdConverter"   , converterInput.Data(), "");
 
@@ -220,8 +222,9 @@ const char* AliHLTTPCAgent::GetReconstructionChains(AliRawReader* /*rawReader*/,
     // reconstruction chains for AliRoot simulation
     // Note: run loader is only available while running embedded into
     // AliRoot simulation
-    if (runloader->GetLoader("TPCLoader") != NULL)
-      return "TPC-esd-converter TPC-clusters";
+    //if (runloader->GetLoader("TPCLoader") != NULL)
+      //return "TPC-esd-converter TPC-clusters";
+      return "TPC-clusters";
   }
   return NULL;
 }

diff --git a/HLT/TPCLib/AliHLTTPCEsdWriterComponent.cxx b/HLT/TPCLib/AliHLTTPCEsdWriterComponent.cxx
index 9b3540a5d8b2c38c5a48e061b46eb741d34c814b..d071f2ba7d2cdbed9f30a9a022fefa34070a577d 100644 (file)
--- a/HLT/TPCLib/AliHLTTPCEsdWriterComponent.cxx
+++ b/HLT/TPCLib/AliHLTTPCEsdWriterComponent.cxx
@@ -419,6 +419,7 @@ void AliHLTTPCEsdWriterComponent::AliConverter::GetInputDataTypes(AliHLTComponen
   // see header file for class documentation
   list.push_back(AliHLTTPCDefinitions::fgkTrackSegmentsDataType);
   list.push_back(AliHLTTPCDefinitions::fgkTracksDataType);
+  list.push_back( kAliHLTDataTypeTrack|kAliHLTDataOriginTPC );
 }
 
 AliHLTComponentDataType AliHLTTPCEsdWriterComponent::AliConverter::GetOutputDataType()

diff --git a/HLT/global/AliHLTGlobalAgent.cxx b/HLT/global/AliHLTGlobalAgent.cxx
index 7acfe7f6eb8ad5f6f4d1677d439aa85db5ae3928..30199f0dbe4ed3f4b81935595950877f15e384ae 100644 (file)
--- a/HLT/global/AliHLTGlobalAgent.cxx
+++ b/HLT/global/AliHLTGlobalAgent.cxx
@@ -24,9 +24,13 @@
 
 #include <cassert>
 #include "AliHLTGlobalAgent.h"
+#include "AliHLTConfigurationHandler.h"
+#include "TObjString.h"
+#include "TObjArray.h"
 
 // header files of library components
 #include "AliHLTGlobalTrackMergerComponent.h"
+#include "AliHLTGlobalEsdConverterComponent.h"
 
 /** global instance for agent registration */
 AliHLTGlobalAgent gAliHLTGlobalAgent;
@@ -56,35 +60,82 @@ int AliHLTGlobalAgent::RegisterComponents(AliHLTComponentHandler* pHandler) cons
   assert(pHandler);
   if (!pHandler) return -EINVAL;
   pHandler->AddComponent(new AliHLTGlobalTrackMergerComponent);
+  pHandler->AddComponent(new AliHLTGlobalEsdConverterComponent);
   return 0;
 }
 
-int AliHLTGlobalAgent::GetHandlerDescription(AliHLTComponentDataType dt,
-                                          AliHLTUInt32_t /*spec*/,
-                                         AliHLTOUTHandlerDesc& desc) const
+int AliHLTGlobalAgent::CreateConfigurations(AliHLTConfigurationHandler* pHandler,
+                                           AliRawReader* /*rawReader*/,
+                                           AliRunLoader* /*runloader*/) const
 {
   // see header file for class documentation
+  if (!pHandler) return -EINVAL;
+
+  /////////////////////////////////////////////////////////////////////////////////////
+  //
+  // assembly of the global ESD
+
+  // define the inputs to the global ESD
+  TString esdInputs="TPC-globalmerger TPC-mcTrackMarker";
+
+  // check for the availibility
+  TObjArray* pTokens=esdInputs.Tokenize(" ");
+  esdInputs="";
+  if (pTokens) {
+    for (int n=0; n<pTokens->GetEntriesFast(); n++) {
+      TString module=((TObjString*)pTokens->At(n))->GetString();
+      if (pHandler->FindConfiguration(module.Data())) {
+       esdInputs+=module;
+       esdInputs+=" ";
+      }
+    }
+    delete pTokens;
+  }
 
-  // handler for the HLT readou list and global data data blocks {'HLTRDLST':'HLT '}
-  if (dt==AliHLTComponentDataTypeInitializer("HLTRDLST", kAliHLTDataOriginOut) ||
-      dt==AliHLTComponentDataTypeInitializer("HLTTRGDT", kAliHLTDataOriginOut)) {
-      desc=AliHLTOUTHandlerDesc(kProprietary, dt, GetModuleId());
-      return 1;
+  if (esdInputs.Length()>0) {
+    HLTInfo("Configuring inputs to global HLT ESD: %s", esdInputs.Data());
+  } else {
+    HLTWarning("No inputs to global HLT ESD found");
   }
 
+  pHandler->CreateConfiguration("GLOBAL-esd-converter", "GlobalEsdConverter", esdInputs.Data(), "");
+  
   return 0;
 }
 
-AliHLTOUTHandler* AliHLTGlobalAgent::GetOutputHandler(AliHLTComponentDataType dt,
-                                                  AliHLTUInt32_t /*spec*/)
+const char* AliHLTGlobalAgent::GetReconstructionChains(AliRawReader* /*rawReader*/,
+                                                   AliRunLoader* runloader) const
 {
   // see header file for class documentation
-
-  // handler for the HLT readou list and global data data blocks {'HLTRDLST':'HLT '}
-  if (dt==AliHLTComponentDataTypeInitializer("HLTRDLST", kAliHLTDataOriginOut) ||
-      dt==AliHLTComponentDataTypeInitializer("HLTTRGDT", kAliHLTDataOriginOut)) {
-    return NULL;
+  if (runloader) {
+    // reconstruction chains for AliRoot simulation
+    // Note: run loader is only available while running embedded into
+    // AliRoot simulation
+    return "GLOBAL-esd-converter";
   }
+  return NULL;
+}
+
+const char* AliHLTGlobalAgent::GetRequiredComponentLibraries() const
+{
+  // see header file for class documentation
+
+  return "libAliHLTUtil.so libAliHLTRCU.so libAliHLTTPC.so libAliHLTITS.so";
+}
+
+int AliHLTGlobalAgent::GetHandlerDescription(AliHLTComponentDataType /*dt*/,
+                                            AliHLTUInt32_t /*spec*/,
+                                            AliHLTOUTHandlerDesc& /*desc*/) const
+{
+  // see header file for class documentation
+
+  return 0;
+}
+
+AliHLTOUTHandler* AliHLTGlobalAgent::GetOutputHandler(AliHLTComponentDataType /*dt*/,
+                                                     AliHLTUInt32_t /*spec*/)
+{
+  // see header file for class documentation
 
   return NULL;
 }

diff --git a/HLT/global/AliHLTGlobalAgent.h b/HLT/global/AliHLTGlobalAgent.h
index b58596768476609063ff2f0c3554ef492d9e280b..f16cd9dddab1ccc0abe2a18ab4c028f1352df48c 100644 (file)
--- a/HLT/global/AliHLTGlobalAgent.h
+++ b/HLT/global/AliHLTGlobalAgent.h
@@ -34,6 +34,42 @@ class AliHLTGlobalAgent : public AliHLTModuleAgent {
 
   int RegisterComponents(AliHLTComponentHandler* pHandler) const;
 
+  /**
+   * Inherited from AliHLTModuleAgent
+   * Register all configurations belonging to this module with the
+   * AliHLTConfigurationHandler. The agent can adapt the configurations
+   * to be registered to the current AliRoot setup by checking the
+   * runloader.
+   * @param handler      the configuration handler
+   * @param rawReader    AliRawReader instance
+   * @param runloader    AliRoot runloader
+   * @return neg. error code if failed
+   */
+  int CreateConfigurations(AliHLTConfigurationHandler* handler,
+                          AliRawReader* rawReader=NULL,
+                          AliRunLoader* runloader=NULL) const;
+
+  /**
+   * Inherited from AliHLTModuleAgent
+   * Get the top configurations belonging to this module.
+   * A top configuration describes a processing chain. It can simply be
+   * described by the last configuration(s) in the chain. 
+   * The agent can adapt the configurations to be registered to the current
+   * AliRoot setup by checking the runloader.
+   * @param rawReader    AliRawReader instance
+   * @param runloader    AliRoot runloader
+   * @return number of configurations, neg. error code if failed
+   */
+  const char* GetReconstructionChains(AliRawReader* rawReader=NULL,
+                                     AliRunLoader* runloader=NULL) const;
+
+  /**
+   * Inherited from AliHLTModuleAgent
+   * Component libraries which the configurations of this agent depend on.
+   * @return list of component libraries as a blank-separated string.
+   */
+  const char* GetRequiredComponentLibraries() const;
+
   int GetHandlerDescription(AliHLTComponentDataType dt,
                            AliHLTUInt32_t spec,
                            AliHLTOUTHandlerDesc& desc) const;