defining the default reconstruction chain for the HLT ITS
authorrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 3 Jul 2009 10:28:30 +0000 (10:28 +0000)
committerrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 3 Jul 2009 10:28:30 +0000 (10:28 +0000)
HLT/ITS/AliHLTITSAgent.cxx
HLT/ITS/AliHLTITSAgent.h

index 0c37c54..4283705 100644 (file)
@@ -26,7 +26,7 @@
 #include "AliHLTITSAgent.h"
 #include "AliHLTConfiguration.h"
 #include "AliHLTOUT.h"
-//#include "AliDAQ.h"
+#include "AliHLTDAQ.h"
 
 // header files of library components
 
@@ -61,18 +61,53 @@ AliHLTITSAgent::~AliHLTITSAgent()
   // see header file for class documentation
 }
 
-int AliHLTITSAgent::CreateConfigurations(AliHLTConfigurationHandler* /*handler*/,
-                                           AliRawReader* /*rawReader*/,
+int AliHLTITSAgent::CreateConfigurations(AliHLTConfigurationHandler* handler,
+                                           AliRawReader* rawReader,
                                            AliRunLoader* /*runloader*/) const
 {
   // see header file for class documentation
+  int iResult=0;
+  if (!handler) return -EINVAL;
+
+  ///////////////////////////////////////////////////////////////////////////////////////////////////
+  ///////////////////////////////////////////////////////////////////////////////////////////////////
+  //
+  // ITS tracking is currently only working on raw data
+  // to run on digits, a digit publisher needs to be implemented
+  if (rawReader) {
+
+    ///////////////////////////////////////////////////////////////////////////////////////////////////
+    //
+    // define the ITS cluster finder components
+    //
+
+    TString trackerInput;
+    for (int detectorId=0; detectorId<3; detectorId++) {
+      iResult=CreateCFConfigurations(handler, detectorId, trackerInput);
+    }
+    
+    if (handler->FindConfiguration("TPC-globalmerger")) {
+      trackerInput+=" TPC-globalmerger";
+    }
+    handler->CreateConfiguration("ITS-tracker","ITSTracker",trackerInput.Data(),"");
+  }
+
   return 0;
 }
 
 const char* AliHLTITSAgent::GetReconstructionChains(AliRawReader* /*rawReader*/,
-                                                      AliRunLoader* /*runloader*/) const
+                                                      AliRunLoader* runloader) const
 {
   // see header file for class documentation
+  if (runloader) {
+    // reconstruction chains for AliRoot simulation
+    // Note: run loader is only available while running embedded into
+    // AliRoot simulation
+
+    // the chain is just defined and can be used as input for subsequent
+    // components
+    //return "ITS-tracker";
+  }
 
   return "";
 }
@@ -80,7 +115,7 @@ const char* AliHLTITSAgent::GetReconstructionChains(AliRawReader* /*rawReader*/,
 const char* AliHLTITSAgent::GetRequiredComponentLibraries() const
 {
   // see header file for class documentation
-  return "";
+  return "libAliHLTUtil.so libAliHLTRCU.so libAliHLTTPC.so";
 }
 
 int AliHLTITSAgent::RegisterComponents(AliHLTComponentHandler* pHandler) const
@@ -195,3 +230,53 @@ int AliHLTITSAgent::AliHLTOUTSDDRawDataHandler::ProcessData(AliHLTOUT* pData)
   }
   return iResult;
 }
+
+int AliHLTITSAgent::CreateCFConfigurations(AliHLTConfigurationHandler* pHandler, int detectorId, TString& output) const
+{
+  // see header file for class documentation
+  if (!pHandler) return -EINVAL;
+
+  ///////////////////////////////////////////////////////////////////////////////////////////////////
+  //
+  // define the ITS cluster finder components
+  //
+    
+  //The spec starts from 0x1 in SPD, SDD and SSD. So 0x1 is ddl 0 for SPD, 0x10 is ddl 1, and so on
+  //in SDD 0x1 is ddl 256, 0x10 is ddl 257, and so on. This means that the spec has to be set to 0x1 
+  //before the loops over the clusterfinder
+
+  TString idString=AliHLTDAQ::DetectorName(detectorId);
+  if (idString.CompareTo("ITSSPD") &&
+      idString.CompareTo("ITSSDD") &&
+      idString.CompareTo("ITSSSD")) {
+    HLTError("invalid detector id %d does not describe any ITS detector", detectorId);
+    return -ENOENT;
+  }
+
+  int minddl=AliHLTDAQ::DdlIDOffset(detectorId);
+  int maxddl=minddl+=AliHLTDAQ::NumberOfDdls(detectorId);
+  int spec=0x1;
+  int ddlno=0;
+
+  TString origin=idString; origin.ReplaceAll("ITS", "I");
+  TString cfBase=idString; cfBase+="_CF";
+  TString componentId=idString; componentId.ReplaceAll("ITS", "ITSClusterFinder");
+  for(ddlno=minddl;ddlno<=maxddl;ddlno++){  
+    TString arg, publisher, cf;
+    // the HLT origin defines are 4 chars: ISPD, ISSD, ISDD respectively
+    arg.Form("-minid %d -datatype 'DDL_RAW ' '%s' -dataspec 0x%08x -verbose",ddlno, origin.Data(), spec);
+    publisher.Form("ITS-DP_%d", ddlno);
+    pHandler->CreateConfiguration(publisher.Data(), "AliRawReaderPublisher", NULL , arg.Data());
+
+    cf.Form("%s_%d",cfBase.Data(), ddlno);
+    pHandler->CreateConfiguration(cf.Data(), componentId.Data(), publisher.Data(), "");
+
+    if (output.Length()>0) output+=" ";
+    output+=cf;
+
+    spec=spec<<1;
+  }
+  
+  return 0;
+}
index 39fba19..d1af533 100644 (file)
@@ -42,13 +42,14 @@ class AliHLTITSAgent : public AliHLTModuleAgent {
   virtual ~AliHLTITSAgent();
 
   /**
-   * Register all configurations belonging to the sample library with the
+   * 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   [in] the configuration handler
-   * @param rawReader [in] AliRoot RawReader instance 
-   * @param runloader [in] AliRoot runloader
+   * @param handler      the configuration handler
+   * @param rawReader    AliRawReader instance
+   * @param runloader    AliRoot runloader
    * @return neg. error code if failed
    */
   int CreateConfigurations(AliHLTConfigurationHandler* handler,
@@ -56,35 +57,59 @@ class AliHLTITSAgent : public AliHLTModuleAgent {
                           AliRunLoader* runloader=NULL) const;
 
   /**
-   * Get the top configurations for local event reconstruction.
+   * 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 [in] AliRoot RawReader instance 
-   * @param runloader [in] AliRoot runloader
-   * @return string containing the top configurations separated by blanks
+   * @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;
 
   /**
+   * Inherited from AliHLTModuleAgent
    * Register components for the AliHLTSample library.
    * @param pHandler  [in] instance of the component handler          
    */
   int RegisterComponents(AliHLTComponentHandler* pHandler) const;
 
+  /**
+   * Inherited from AliHLTModuleAgent
+   * Return HLTOUT handler description for a certain data block in the
+   * HLTOUT payload.
+   * @return 1 if module provides a handler
+   */
   int GetHandlerDescription(AliHLTComponentDataType dt,
                            AliHLTUInt32_t spec,
                            AliHLTOUTHandlerDesc& desc) const;
+
+  /**
+   * Inherited from AliHLTModuleAgent
+   * Create HLTOUT handler for a certain data block in the
+   * HLTOUT payload. The same handler can be returned multiple
+   * times, even for different data types. The framework will
+   * handle this.
+   * @return pointer to handler
+   */
   AliHLTOUTHandler* GetOutputHandler(AliHLTComponentDataType dt,
                                     AliHLTUInt32_t spec);
+
+  /**
+   * Inherited from AliHLTModuleAgent
+   * Delete the instance of the handler. This is only called once
+   * even if the same handler has been issued multiple times
+   */
   int DeleteOutputHandler(AliHLTOUTHandler* pInstance);
 
   AliHLTModulePreprocessor* GetPreprocessor();
@@ -97,9 +122,20 @@ class AliHLTITSAgent : public AliHLTModuleAgent {
   private:
   };
 
+  /**
+   * Create configurations for all CFs for the ITS subdetectors
+   * Get the necessary information from AliDAQ using the detector id.
+   * @param pHandler       Instance of the configuration handler 
+   * @param detectorId     Id of the detector as specified in AliDAQ
+   * @param output         Target string to receive the configurations
+   * @return neg. error code f failed
+   */
+  int CreateCFConfigurations(AliHLTConfigurationHandler* pHandler, int detectorId, TString& output) const;
+
  protected:
 
  private:
+
   /** copy constructor prohibited */
   AliHLTITSAgent(const AliHLTITSAgent&);
   /** assignment operator prohibited */