HLT/rec/AliHLTReconstructor.h

   1 // @(#) $Id$
   2
   3 #ifndef ALIHLTRECONSTRUCTOR_H
   4 #define ALIHLTRECONSTRUCTOR_H
   5 //* This file is property of and copyright by the ALICE HLT Project        *
   6 //* ALICE Experiment at CERN, All rights reserved.                         *
   7 //* See cxx source for full Copyright notice                               *
   8
   9 /** @file   AliHLTReconstructor.h
  10     @author Matthias Richter
  11     @date
  12     @brief  Binding class for HLT simulation in AliRoot
  13 */
  14
  15 #include "AliReconstructor.h"
  16 #include "AliHLTReconstructorBase.h"
  17
  18 class AliHLTSystem;
  19 class AliRawReader;
  20 class AliESDEvent;
  21 class AliHLTOUT;
  22 class AliHLTEsdManager;
  23
  24 /**
  25  * @class AliHLTReconstructor
  26  * AliHLTReconstructor AliRoot event reconstruction plugin for the HLT.
  27  * The AliHLTReconstructor holds an instance of the @ref AliHLTSystem
  28  * steering class. The actual reconstruction depends on the loaded component
  29  * libraries. Each library must implement a module agent (@ref AliHLTModuleAgent)
  30  * in order to provide information on the supported features and the
  31  * configurations to be run.
  32  *
  33  * The default component libraries which are loaded through the initialization
  34  * are determined by the @ref AliHLTSystem::fgkHLTDefaultLibs array. The library
  35  * loading can be overridden by an option to the AliHLTReconstructor through the
  36  * <tt>SetOption</tt> method of <tt>AliReconstruction</tt>, e.g.
  37  * <pre>
  38  * AliReconstruction rec;
  39  * rec.SetOption("HLT", "libAliHLTSample.so");
  40  * </pre>
  41  * will only load <tt>libAliHLTSample.so</tt>
  42  *
  43  * Optional arguments:<br>
  44  * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formating -->
  45  * \li loglevel=<i>level</i><br>
  46  *     level can be a hex number encoding the @ref AliHLTComponentLogSeverity
  47  * \li alilog=off <br>
  48  *     disables the logging of HLT log messages through <tt>AliLog</tt> <br>
  49  *
  50  * For further information on the AliRoot reconstruction refer to the AliRoot
  51  * documentation, namely <tt>AliReconstruction</tt>.
  52  */
  53 class AliHLTReconstructor: public AliReconstructor, public AliHLTReconstructorBase {
  54 public:
  55   /** standard constructor */
  56   AliHLTReconstructor();
  57   /** constructor */
  58   AliHLTReconstructor(const char* options);
  59   /** destructor */
  60   virtual ~AliHLTReconstructor();
  61
  62   /** init the reconstructor */
  63   void Init();
  64
  65   /** init the reconstructor */
  66   void Init(const char* options);
  67
  68   /**
  69    * This Reconstructor function is not applicable for the AliHLTReconstructor
  70    * as it gets a detector specific digits tree. But HLT processes all detectors.
  71    * Furthermore it's purely simulated data. <br>
  72    * The function forwards to the default bahavior of AliReconstructor but gives
  73    * a warning if there were options set, i.e. the user runs customized
  74    * reconstruction.
  75    *
  76    * @note HLT reconstruction on simulated data is processed at the end of
  77    * simulation. <br>
  78    */
  79   void Reconstruct(TTree* digitsTree, TTree* clustersTree) const;
  80
  81   /**
  82    * Reconstruction from RAW data.
  83    * The rawReader holds data for all detectors and this version of Reconstruct
  84    * is thus applicable for the HLT. The clustersTree is just ignored.
  85    */
  86   void Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const;
  87
  88   /**
  89    * This function treats the simulated HLTOUT data.
  90    * Opens a handler for simulated HLTOUT data and forwards to ::ProcessHLTOUT.
  91    */
  92   void FillESD(TTree* digitsTree, TTree* clustersTree, AliESDEvent* esd) const;
  93
  94   /**
  95    * Process the raw HLTOUT data and fill ESD.
  96    * Opens a handler for raw HLTOUT data and forwards to ::ProcessHLTOUT.
  97    */
  98   void FillESD(AliRawReader* rawReader, TTree* clustersTree, AliESDEvent* esd) const;
  99
 100   /**
 101    * Process HLTOUT data and fill ESD.
 102    * This is the final treatment of the HLTOUT data, either simulated or real.
 103    * HLTOUT data is stored in HOMER format, the AliHLTOUT object provides the interface
 104    * to the individual data blocks.
 105    *
 106    * During reconstruction (::Reconstruct), module or user defined chains can be
 107    * processed and may add additional data to the HLTOUT object. This data is then
 108    * treated in the same way.
 109    */
 110   void ProcessHLTOUT(AliHLTOUT* pHLTOUT, AliESDEvent* esd) const;
 111
 112   /**
 113    * Process HLTOUT data.
 114    * Open digit file and process the HLTOUT digit data.
 115    * This function is mostly intended for debugging purposes and stand-alone
 116    * processing of the output from the simulation. Loops over all events.
 117    * @param digitFile        path of the digit file
 118    * @param pEsd             optional ESD to be filled
 119    */
 120   void ProcessHLTOUT(const char* digitFile="HLT.Digits.root", AliESDEvent* pEsd=NULL) const;
 121
 122   /**
 123    * Process HLTOUT data.
 124    * Process the HLTOUT from the raw reader.
 125    * This function is mostly intended for debugging purposes and stand-alone
 126    * processing of simulated or real raw data.
 127    * \em Note: Loops over all events, i.e. the current event of the the raw
 128    * reader will change. Not to be called inside the normal AliRoot processsing.
 129    * @param pRawReader       raw reader instance
 130    * @param pEsd             optional ESD to be filled
 131    */
 132   void ProcessHLTOUT(AliRawReader* pRawReader, AliESDEvent* pEsd=NULL) const;
 133
 134   /**
 135    * Print a short info about the HLTOUT content.
 136    */
 137   void PrintHLTOUTContent(AliHLTOUT* pHLTOUT) const;
 138
 139 private:
 140   /** copy constructor prohibited */
 141   AliHLTReconstructor(const AliHLTReconstructor& src);
 142   /** assignment operator prohibited */
 143   AliHLTReconstructor& operator=(const AliHLTReconstructor& src);
 144
 145   /** function pointer: processing of HLTOUT data */
 146   void* fFctProcessHLTOUT; //!transient
 147
 148   /** ESD manger instance for this reconstruction */
 149   AliHLTEsdManager* fpEsdManager; //!transient
 150
 151   ClassDef(AliHLTReconstructor, 5)   // class for the HLT reconstruction
 152
 153 };
 154
 155 typedef AliHLTReconstructor AliL3Reconstructor; // for backward compatibility
 156
 157 #endif