documentation
authorrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 13 May 2008 09:13:14 +0000 (09:13 +0000)
committerrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 13 May 2008 09:13:14 +0000 (09:13 +0000)
HLT/BASE/AliHLTModuleAgent.h
HLT/BASE/AliHLTOUTHandlerEquId.h
HLT/doc/doxygen.conf.in
HLT/rec/AliHLTEsdManager.h
HLT/rec/AliHLTReconstructor.h
HLT/rec/AliRawReaderHLT.h

index b1b3bea..49c9a4a 100644 (file)
@@ -288,6 +288,12 @@ class AliHLTModuleAgent : public TObject, public AliHLTLogging {
 
   /**
    * Get handler description for a data block.
+   * Depending on the data type and data specification the handler must
+   * provide information
+   * - if it can handle the data block, and
+   * - details how it will handle it, mainly the type of the handler
+   *   @ref AliHLTOUTHandlerType
+   * 
    * @param dt        [in] data type of the block
    * @param spec      [in] specification of the block
    * @param desc      [out] handler description
index 744cc3a..c02de55 100644 (file)
 
 /**
  * @class AliHLTOUTHandlerEquId
- * HLT output handler returning equipment ids for redirection of data blocks
- * of the HLTOUT stream to the original detector streams.
+ * Base class for DDL raw data redirection handlers.
+ *
+ * HLTOUT handlers of this type are used for the replacement of detector
+ * reconstruction input by the corresponding data from the HLT output.
+ * From the data type and specification of an HLT output block the
+ * corresponding equipment id of the original detector streams is determined.
  *
  * The class introduces a layer in the HLTOUT handler hierarchy in order to
  * collect all handlers which can be used by the AliRawReaderHLT for
  * redirection of HLTOUT data blocks and replacement of original detector
  * data. The common denominator of all those handlers is the data format.
- * The data block itsself or the decoded data produced by the handler have
+ * The data block itself or the decoded data produced by the handler have
  * exactly the detector raw data format. Thus, the data streams can be
  * transparently replaced in the AliRoot reconstruction.
  *
  * The handler might produce decoded data from the data block in order
  * the get the right data format. The AliRawReaderHLT will try to fetch
  * those data by calling AliHLTOUTHandler::GetProcessedData(). If no data
- * is provided, the input block itsself is treated as the data to redirect.
+ * is provided, the input block itself is treated as the data to redirect.
+ *
+ * @ingroup alihlt_aliroot_reconstruction
  */
 class AliHLTOUTHandlerEquId : public AliHLTOUTHandler {
  public:
@@ -44,7 +50,7 @@ class AliHLTOUTHandlerEquId : public AliHLTOUTHandler {
    * Process a data block.
    * The handler retrieves the data and it's properties and derives the
    * equipment id from it. The default behavior returns the specification as
-   * equipment id and does not touch the data itsself.
+   * equipment id and does not touch the data itself.
    * @return equipment id the block should be used for.
    */
   virtual int ProcessData(AliHLTOUT* pData);
index d60c299..3d10531 100644 (file)
@@ -71,6 +71,7 @@ INPUT                  = @top_srcdir@/doc     \
                         @top_srcdir@/SampleLib \
                         @top_srcdir@/rec       \
                         @top_srcdir@/exa       \
+                        @top_srcdir@/shuttle   \
                         @top_srcdir@/sim
 
 FILE_PATTERNS          = *.h *.c *.cpp *.hpp *.cxx *.C
index 122fd81..8c32acc 100644 (file)
@@ -34,7 +34,7 @@ class TFile;
  * E.g. the ESD from a data block of type {ESD_TREE,TPC} will be added to the
  * file AliHLTTPCESDs.root.
  *
- * @ingroup alihlt_out
+ * @ingroup alihlt_aliroot_reconstruction
  */
 class AliHLTEsdManager : public AliHLTLogging {
  public:
index cd808c1..d58be1f 100644 (file)
@@ -20,10 +20,32 @@ class AliRawReader;
 class AliESDEvent;
 class AliHLTOUT;
 class AliHLTEsdManager;
+/**
+ * @defgroup alihlt_aliroot_reconstruction AliRoot reconstruction.
+ *
+ * Like all other ALICE detectors, HLT utilizes the AliReconstruction interface
+ * to implement a plugin for the AliRoot reconstruction. The reconstructor can be
+ * used to
+ * - run HLT analysis chains in the AliRoot reconstruction <br>
+ *   This option is mainly intended for the development and debugging cycle. HLT
+ *   chains can be defined by means of AliHLTConfiguration and can be run either
+ *   stand-alone or embedded into the AliReconstruction cycle.
+ * - run the default analysis chains <br>
+ *   HLT modules can define default analysis chains to be run during AliRoot
+ *   reconstruction.
+ * - handle the HLTOUT data<br>
+ *   The HLT output stream contains multiple data blocks produced by the various
+ *   components of the HLT chain. Each block might need different and even
+ *   detector specific processing, like e.g. the processing of ESD objects or the
+ *   handling of compressed data.
+ *
+ * The AliHLTReconstructor provides the main interface for this group.
+ * @ingroup alihlt_system
+ */
 
 /**
  * @class AliHLTReconstructor
- * AliHLTReconstructor AliRoot event reconstruction plug-in for the HLT.
+ * AliRoot event reconstruction plug-in for the HLT.
  * The AliHLTReconstructor holds an instance of the @ref AliHLTSystem
  * steering class. The actual reconstruction depends on the loaded component
  * libraries. Each library must implement a module agent (@ref AliHLTModuleAgent)
@@ -89,11 +111,11 @@ class AliHLTEsdManager;
  *      @ref sec_alihltreconstructor_hltout_proprietary
  *
  * @subsection sec_alihltreconstructor_hltout_esd ESD HLTOUT data
- * The frame work implements a standard handling of
- * ESD data blocks of type ::kAliHLTDataTypeESDTree {ESD_TREE:ANY}. ANY can be
+ * The framework implements a standard handling of ESD data
+ * blocks of type ::kAliHLTDataTypeESDTree {ESD_TREE:ANY}. \em ANY can be
  * any detector origin. Each ESD block contains the data of only one event,
  * the ESDs are merged by the AliHLTEsdManager and written to files of the
- * naming scheme AliHLT<DET>ESDs.root. The first ESD block is also copied
+ * naming scheme AliHLT\lt\em DET \gt ESDs.root. The first ESD block is also copied
  * to the hltEsd provided by the AliReconstruction. This is a temporary
  * solution as the handling and merging of HLT ESDs is under discussion.
  * At the time of writing (May 08) only the TPC HLT components produce ESD
@@ -101,19 +123,21 @@ class AliHLTEsdManager;
  * The module agent can provide a handler for multiple ESD data blocks, e.g.
  * for merging within one event prior to the writing. Instead of the individual
  * ESDs the one provided by the handler is passed to the AliHLTEsdManager. The
- * handler is of type AliHLTModuleAgent::AliHLTOUTHandlerType::kEsd
+ * handler is of type \link AliHLTModuleAgent::AliHLTOUTHandlerType kEsd \endlink.
  *
  * @subsection sec_alihltreconstructor_hltout_rawreader DDL raw HLTOUT data
  * The HLT can perform selective readout and produces a reduced amount of data
  * in the original raw ddl format. In order to feed this data from the HLTOUT
  * DDL links into the normal reconstruction, a handler of type 
- * @ref AliHLTModuleAgent::AliHLTOUTHandlerType::kRawReader must be implemented and provided by the
+ * \link AliHLTModuleAgent::AliHLTOUTHandlerType kRawReader \endlink must be
+ * implemented and provided by the
  * module agent. The handler has to derive the original equipment id from the
  * data type and specification of the block. The offline reconstruction does
- * not need to be changed or adapted at all.
+ * not need to be changed or adapted at all. See AliRawReaderHLT for details.
  *
  * @subsection sec_alihltreconstructor_hltout_rawstream Preprocessed Raw HLTOUT data
- * Handlers type @ref AliHLTModuleAgent::AliHLTOUTHandlerType::kRawStream are foreseen though at the time of writing (May 08) the
+ * Handlers of type \link AliHLTModuleAgent::AliHLTOUTHandlerType kRawStream \endlink
+ * are foreseen though at the time of writing (May 08) the
  * concept is not fixed. Advanced data compression algorithms can produce a
  * raw data format which is not convertible into the raw DDL data, e.g. lossy
  * compression techniques storing clusters parametrized regarding to tracks. A
@@ -121,15 +145,29 @@ class AliHLTEsdManager;
  * first stage of the offline reconstruction might need some adaptions.
  *
  * @subsection sec_alihltreconstructor_hltout_chain HLTOUT data fed into a chain
- * At the time of writing (May 08), handler type @ref AliHLTModuleAgent::AliHLTOUTHandlerType::kChain
+ * At the time of writing (May 08), handler type 
+ * \link AliHLTModuleAgent::AliHLTOUTHandlerType kChain \endlink
  * is foreseen but not yet implemented. Has to be discussed.
  *
  * @subsection sec_alihltreconstructor_hltout_proprietary Proprietary HLTOUT data
- * This is a handler of proprietary detector data, @ref AliHLTModuleAgent::AliHLTOUTHandlerType::kProprietary.
- * Handlers of this type do not have any standard output to the framework. Data
- * can be processed and stored to files.
+ * This is a handler of proprietary detector data. Handlers of type 
+ * \link AliHLTModuleAgent::AliHLTOUTHandlerType kProprietary \endlink
+ * do not have any standard output to the framework. Data can be processed and
+ * stored to files.
+ *
+ * @section sec_alihltreconstructor_helper Tools and helper functions
+ * @subsection sec_alihltreconstructor_hltout_standalone Stand-alone HLTOUT processing
+ * - HLTOUT processing from a digit file:
+ * <pre>
+ *  void ProcessHLTOUT(const char*, AliESDEvent*) const;
+ * </pre>
+ * - HLTOUT processing from an AliRawReader
+ * <pre>
+ *  void ProcessHLTOUT(AliRawReader*, AliESDEvent*) const;
+ * </pre>
  *
  * @ingroup alihlt_aliroot_reconstruction
+ * @section sec_alihltreconstructor_members Class members
  */
 class AliHLTReconstructor: public AliReconstructor, public AliHLTReconstructorBase {
 public:
index c9e0b66..9d85a2f 100644 (file)
@@ -30,7 +30,55 @@ class AliHLTOUTHandler;
 
 /**
  * @class AliRawReaderHLT
- * Handler of HLTOUT data for AliRawReader input.
+ * A specific AliRawReader for detector input replacement by HLTOUT data blocks.
+ *
+ * HLT components can produce output data in the detector ddl raw format.
+ * Data blocks of this format can be fed into the normal detector reconstruction
+ * without changes in the actual reconstruction code by means of the
+ * AliRawReaderHLT implementation of the AliRawReader.
+ *
+ * @section sec_alirawreaderhlt_concept Conceptual design
+ * The AliRawReader provides an abstract interface to the ddl raw data. All
+ * reconstruction code uses this interface to access the data.
+ * HLT components can send their data in the original ddl raw format. The only
+ * difference of such data blocks is the location since they are shipped as
+ * part of the HLTOUT data stream. The AliRawReaderHLT provides redirection of
+ * those data blocks.
+ *
+ * @section sec_alirawreaderhlt_usage   Selection of the HLTOUT data stream
+ * The input data of a detector can be replaced by the corresponding HLT
+ * data by calling the <tt>AliReconstruction::SetUseHLTData("...")</tt>, e.g.
+ * <pre>
+ *    AliReconstruction rec;
+ *    rec.SetUseHLTData("TPC TRD");
+ * </pre>
+ * will replace the input of TPC and TRD.
+ *
+ * @section sec_alirawreaderhlt_module  Module implementation
+ * In order to determine the equipment id for the data block, the HLT module
+ * must implement an HLTOUT handler of class AliHLTOUTHandlerEquId which is of 
+ * type @ref AliHLTModuleAgent::AliHLTOUTHandlerType ::kRawReader.
+ * The handler must implement the method
+ * <pre>
+ *  // AliHLTOUTHandlerEquId::ProcessData(AliHLTOUT*)
+ *  virtual int ProcessData(AliHLTOUT* pData);
+ * </pre>
+ * which returns the equipment id and eventually decodes data to be retrieved
+ * by calling AliHLTOUTHandler::GetProcessedData().
+ *
+ * Secondly, the AliHLTModuleAgent implementation of the module has to create
+ * the handler for the data blocks. Depending on the data type and specification,
+ * the the following interface methods return handler description and handler. 
+ * <pre>
+ *   int AliHLTModuleAgent::GetHandlerDescription(AliHLTComponentDataType dt,
+ *                                                AliHLTUInt32_t spec,
+ *                                                AliHLTOUTHandlerDesc& desc) const;
+ *
+ *   AliHLTOUTHandler* AliHLTModuleAgent::GetOutputHandler(AliHLTComponentDataType dt, 
+ *                                                         AliHLTUInt32_t spec);
+ * </pre>
+ *
+ * @ingroup alihlt_aliroot_reconstruction
  */
 class AliRawReaderHLT : public AliRawReader, public AliHLTReconstructorBase {
  public: