- added skeleton of of offline clusterizer and tracker components
[u/mrichter/AliRoot.git] / 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 formatting -->
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