// @(#) $Id$
#ifndef ALIHLTRECONSTRUCTOR_H
#define ALIHLTRECONSTRUCTOR_H
//* This file is property of and copyright by the ALICE HLT Project *
//* ALICE Experiment at CERN, All rights reserved. *
//* See cxx source for full Copyright notice *
/** @file AliHLTReconstructor.h
@author Matthias Richter
@date
@brief Binding class for HLT simulation in AliRoot
*/
#include "AliReconstructor.h"
class AliHLTSystem;
class AliRawReader;
class AliESDEvent;
class AliHLTOUT;
class AliHLTEsdManager;
class AliHLTPluginBase;
/**
* @defgroup alihlt_aliroot_reconstruction AliRoot reconstruction.
*
* @section alihlt_aliroot_reconstruction_intro General Remarks
* 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
* 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
* HLT modules can define default analysis chains to be run during AliRoot
* reconstruction.
* -# handle the HLTOUT data
* 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.
*
* @section alihlt_aliroot_reconstruction_steering Steering
* The AliHLTReconstructor provides the main interface for the reconstruction.
* The handling of the HLTOUT data is described in AliRawReaderHLT.
*
* @section alihlt_aliroot_reconstruction_examples Examples
* @subsection alihlt_aliroot_reconstruction_examples_reco Run chains
* - @ref tut_reconstruction
*
* @subsection alihlt_aliroot_reconstruction_examples_hltout Handle HLTOUT
* - @ref tut_alirawreaderhlt
*
* @ingroup alihlt_system
*/
/**
* @class AliHLTReconstructor
* 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)
* in order to provide information on the supported features and the
* configurations to be run.
*
* The AliHLTReconstructor provides both the functionality to run customized
* analysis chains and the treatment of the HLTOUT data.
*
* @section sec_alihltreconstructor_options Options
* The default component libraries which are loaded through the initialization
* are determined by the @ref AliHLTSystem::fgkHLTDefaultLibs array. The library
* loading can be overridden by an option to the AliHLTReconstructor through the
* SetOption method of AliReconstruction, e.g.
*
* AliReconstruction rec; * rec.SetOption("HLT", "libAliHLTSample.so"); ** will only load libAliHLTSample.so * * Optional arguments:
* rec.SetOption("HLT", "config=[macro.C] chains=[name]") ** - providing the configuration and the name by the module agent. * AliHLTModuleAgent and the functions AliHLTModuleAgent::CreateConfigurations * and AliHLTModuleAgent::GetReconstructionChains * * @section sec_alihltreconstructor_hltout Treatment of HLTOUT data. * The HLTOUT data is a collation of output blocks produced by the various * components running in an HLT chain. Typically its the output of the last * component(s) in the chain, or components specifically connected to the HLT * output. * * The treatment of the HLTOUT data blocks is implemented in handlers of type * AliHLTOUTHandler. The AliHLTModuleAgent of the module creates the appropriate * handler for a data block. * The data type of the individual blocks is set by the producer component and * specifies the nature of the data processing. There are 5 overall groups: * - output is in ESD format: * @ref sec_alihltreconstructor_hltout_esd * - data describes DDL raw format: * @ref sec_alihltreconstructor_hltout_rawreader * - pre-analyzed data to be fed into the normal reconstruction: * @ref sec_alihltreconstructor_hltout_rawstream * - data is fed into an analysis chain: * @ref sec_alihltreconstructor_hltout_chain * - detector specific handler: * @ref sec_alihltreconstructor_hltout_proprietary * * @subsection sec_alihltreconstructor_hltout_esd ESD HLTOUT data * 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\em DET 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 * blocks. * 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 \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 * \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. See AliRawReaderHLT for details. * * @subsection sec_alihltreconstructor_hltout_rawstream Preprocessed Raw HLTOUT data * 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 * specific RawStream is needed here since the data is detector specific and the * 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 * \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. 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 * Some helper functions of the AliHLTReconstruction can be used in stand-alone * mode. Remember to Init() the reconstructor. *
* { * gSystem->Load("libHLTrec.so"); * AliHLTReconstructor rec; * rec.Init(); * // do something * } ** @subsection sec_alihltreconstructor_hltout_standalone Stand-alone HLTOUT processing * - HLTOUT processing from a digit file: *
* void ProcessHLTOUT(const char*, AliESDEvent*) const; ** - HLTOUT processing from an AliRawReader *
* void ProcessHLTOUT(AliRawReader*, AliESDEvent*) const; ** * @ingroup alihlt_aliroot_reconstruction * @section sec_alihltreconstructor_members Class members */ class AliHLTReconstructor: public AliReconstructor { public: /** standard constructor */ AliHLTReconstructor(); /** constructor */ AliHLTReconstructor(const char* options); /** destructor */ virtual ~AliHLTReconstructor(); /** init the reconstructor */ void Init(); /** init the reconstructor */ void Init(const char* options); /** * Init streamer infos for the relevent classes to be extracted from HLT raw * data payload. Reads the info from HLT/Calib/StreamerInfo */ int InitStreamerInfos(); /** * Init streamer infos for the relevant classes to be extracted from HLT raw * data payload. */ int InitStreamerInfos(TObjArray* pSchemas) const; /** * This Reconstructor function is not applicable for the AliHLTReconstructor * as it gets a detector specific digits tree. But HLT processes all detectors. * Furthermore it's purely simulated data.