Changes required to handle software triggers correctly in the global trigger component.
[u/mrichter/AliRoot.git] / HLT / BASE / AliHLTComponent.h
1 //-*- Mode: C++ -*-
2 // $Id$
3
4 #ifndef ALIHLTCOMPONENT_H
5 #define ALIHLTCOMPONENT_H
6 //* This file is property of and copyright by the ALICE HLT Project        * 
7 //* ALICE Experiment at CERN, All rights reserved.                         *
8 //* See cxx source for full Copyright notice                               *
9
10 //  @file   AliHLTComponent.h
11 //  @author Matthias Richter, Timm Steinbeck
12 //  @date   
13 //  @brief  Base class declaration for HLT components. 
14 //  @note   The class is both used in Online (PubSub) and Offline (AliRoot)
15 //          context
16
17
18 /**
19  * @defgroup alihlt_component Component handling of the HLT module
20  * This section describes the the component base classes and handling for
21  * the HLT module.
22  *
23  * @section alihlt_component_intro General remarks
24  * HLT analysis is organized in so called components. Each component can
25  * subscribe to the data produced by other components and can from the
26  * analysis publish new data for the subsequent components. Only the
27  * input data blocks and entries from CDB are available for the analysis. 
28  *
29  * @section alihlt_component_implementation Component implementation
30  * AliHLTComponent provides the interface for all components, see there
31  * for details. Three types are provided:
32  * - AliHLTProcessor
33  * - AliHLTDataSource
34  * - AliHLTDataSink
35  *
36  * The two last represent data sinks and sources for the HLT integration
37  * into AliRoot. When running only, only the processors are relevant,
38  * sources and sinks are provided by the HLT PubSub framework. Please check
39  * AliHLTComponent for detailed description.
40  *
41  * @section alihlt_component_registration Component registration
42  * Components need to be registered with the AliHLTComponentHandler in
43  * order to be used with the system. Registration is purely done from the
44  * module library. Two methods are possible:
45  * - the module library implements an AliHLTModuleAgent and overloads the
46  *   AliHLTModuleAgent::RegisterComponents() function
47  * - in the implementation file, one object is defined. The global object is
48  *   automatically instantiated when the library is loaded for the first
49  *   time and the object is used for registration.
50  *
51  * In both cases, the library must be loaded via the method
52  * <pre>
53  *  AliHLTComponentHandler::LoadComponentLibraries()
54  * </pre>
55  * For the global object approach it is important that the library is
56  * not loaded elsewhere before (e.g. a gSystem->Load operation in your
57  * rootlogon.C).
58  *
59  *
60  */
61
62 #include <vector>
63 #include <string>
64 #include "AliHLTLogging.h"
65 #include "AliHLTDataTypes.h"
66 #include "AliHLTCommonCDBEntries.h"
67
68 /* Matthias Dec 2006
69  * The names have been changed for Aliroot's coding conventions sake
70  * The old names are defined for backward compatibility with the 
71  * stand alone SampleLib package
72  */
73 typedef AliHLTComponentLogSeverity AliHLTComponent_LogSeverity;
74 typedef AliHLTComponentEventData AliHLTComponent_EventData;
75 typedef AliHLTComponentShmData AliHLTComponent_ShmData;
76 typedef AliHLTComponentDataType AliHLTComponent_DataType;
77 typedef AliHLTComponentBlockData AliHLTComponent_BlockData;
78 typedef AliHLTComponentTriggerData AliHLTComponent_TriggerData;
79 typedef AliHLTComponentEventDoneData AliHLTComponent_EventDoneData;
80
81 class AliHLTComponentHandler;
82 class TObjArray;
83 class TMap;
84 class TStopwatch;
85 class TUUID;
86 class AliRawDataHeader;
87 class AliHLTComponent;
88 class AliHLTMemoryFile;
89 class AliHLTCTPData;
90 class AliHLTReadoutList;
91
92 /** list of component data type structures */
93 typedef vector<AliHLTComponentDataType>   AliHLTComponentDataTypeList;
94 /** list of component block data structures */
95 typedef vector<AliHLTComponentBlockData>  AliHLTComponentBlockDataList;
96 /** list of component statistics struct */
97 typedef vector<AliHLTComponentStatistics> AliHLTComponentStatisticsList;
98 /** list of component pointers */
99 typedef vector<AliHLTComponent*>          AliHLTComponentPList;
100 /** list of memory file pointers */
101 typedef vector<AliHLTMemoryFile*>         AliHLTMemoryFilePList;
102
103 /**
104  * @class AliHLTComponent
105  * Base class of HLT data processing components.
106  * The class provides a common interface for HLT data processing components.
107  * The interface can be accessed from the online HLT framework or the AliRoot
108  * offline analysis framework.
109  * @section alihltcomponent-properties Component identification and properties
110  * Each component must provide a unique ID, input and output data type indications,
111  * and a spawn function.
112  * @subsection alihltcomponent-req-methods Required property methods
113  * - @ref GetComponentID
114  * - @ref GetInputDataTypes (see @ref alihltcomponent-type for default
115  *   implementations.)
116  * - @ref GetOutputDataType (see @ref alihltcomponent-type for default
117  *   implementations.)
118  * - @ref GetOutputDataSize (see @ref alihltcomponent-type for default
119  *   implementations.)
120  * - @ref Spawn
121  *
122  * @subsection alihltcomponent-opt-mehods Optional handlers
123  * - @ref DoInit
124  * - @ref DoDeinit
125  * - @ref GetOutputDataTypes
126  *   If the component has multiple output data types @ref GetOutputDataType
127  *   should return @ref kAliHLTMultipleDataType. The framework will invoke
128  *   @ref GetOutputDataTypes, a list can be filled.
129  * - @ref Reconfigure
130  *   This function is invoked by the framework on a special event which
131  *   triggers the reconfiguration of the component.
132  *
133  * @subsection alihltcomponent-processing-mehods Data processing
134  * 
135  * 
136  * @subsection alihltcomponent-type Component type
137  * Components can be of type
138  * - @ref kSource     components which only produce data 
139  * - @ref kProcessor  components which consume and produce data
140  * - @ref kSink       components which only consume data
141  *
142  * where data production and consumption refer to the analysis data stream. In
143  * order to indicate the type, a child component can overload the
144  * @ref GetComponentType function.
145  * @subsubsection alihltcomponent-type-std Standard implementations
146  * Components in general do not need to implement this function, standard
147  * implementations of the 3 types are available:
148  * - AliHLTDataSource for components of type @ref kSource <br>
149  *   All types of data sources can inherit from AliHLTDataSource and must
150  *   implement the @ref AliHLTDataSource::GetEvent method. The class
151  *   also implements a standard method for @ref GetInputDataTypes.
152  *   
153  * - AliHLTProcessor for components of type @ref kProcessor <br>
154  *   All types of data processors can inherit from AliHLTProcessor and must
155  *   implement the @ref AliHLTProcessor::DoEvent method.
156  *
157  * - AliHLTDataSink for components of type @ref kSink <br>
158  *   All types of data processors can inherit from AliHLTDataSink and must
159  *   implement the @ref AliHLTDataSink::DumpEvent method. The class
160  *   also implements a standard method for @ref GetOutputDataType and @ref
161  *   GetOutputDataSize.
162  *
163  * @subsection alihltcomponent-environment Running environment
164  *
165  * In order to adapt to different environments (on-line/off-line), the component
166  * gets an environment structure with function pointers. The base class provides
167  * member functions for those environment dependend functions. The member 
168  * functions are used by the component implementation and are re-mapped to the
169  * corresponding functions.
170  *
171  * @section alihltcomponent-interfaces Component interfaces
172  * Each of the 3 standard component base classes AliHLTProcessor, AliHLTDataSource
173  * and AliHLTDataSink provides it's own processing method (see
174  * @ref alihltcomponent-type-std), which splits into a high and a low-level
175  * method. For the @ref alihltcomponent-low-level-interface, all parameters are
176  * shipped as function arguments, the component is supposed to write data to the
177  * output buffer and handle all block descriptors. 
178  * The @ref alihltcomponent-high-level-interface is the standard processing
179  * method and will be used whenever the low-level method is not overloaded.
180  *
181  * In both cases it is necessary to calculate/estimate the size of the output
182  * buffer before the processing. Output buffers can never be allocated inside
183  * the component because of the push-architecture of the HLT.
184  * For that reason the @ref GetOutputDataSize function should return a rough
185  * estimatian of the data to be produced by the component. The component is
186  * responsible for checking the memory size and must return -ENOSPC if the
187  * available buffer is too small, and update the estimator respectively. The
188  * framework will allocate a buffer of appropriate size and call the processing
189  * again.
190  *
191  * @subsection alihltcomponent-error-codes Return values/Error codes
192  * For return codes, the following scheme applies:
193  * - The data processing methods have to indicate error conditions by a negative
194  * error/return code. Preferably the system error codes are used like
195  * e.g. -EINVAL. This requires to include the header
196  * <pre>
197  * \#include \<cerrno\>
198  * </pre>
199  * This schema aplies to all interface functions of the component base class.
200  * For data processing it is as follows:
201  * - If no suitable input block could be found (e.g. no clusters for the TPC cluster
202  * finder) set size to 0, block list is empty, return 0
203  * - If no ususable or significant signal could be found in the input blocks
204  * return an empty output block, set size accordingly, and return 0. An empty output
205  * block here could be either a real empty one of size 0 (in which case size also
206  * would have to be set to zero) or a block filled with just the minimum necessary
207  * accounting/meta-structures. E.g. in the TPC
208  *
209  * @subsection alihltcomponent-high-level-interface High-level interface
210  * The high-level component interface provides functionality to exchange ROOT
211  * structures between components. In contrast to the 
212  * @ref alihltcomponent-low-level-interface, a couple of functions can be used
213  * to access data blocks of the input stream
214  * and send data blocks or ROOT TObject's to the output stream. The functionality
215  * is hidden from the user and is implemented by using ROOT's TMessage class.
216  *
217  * @subsubsection alihltcomponent-high-level-int-methods Interface methods
218  * The interface provides a couple of methods in order to get objects from the
219  * input, data blocks (non TObject) from the input, and to push back objects and
220  * data blocks to the output. For convenience there are several functions of 
221  * identical name (and similar behavior) with different parameters defined.
222  * Please refer to the function documentation.
223  * - @ref GetNumberOfInputBlocks <br>
224  *        return the number of data blocks in the input stream
225  * - @ref GetFirstInputObject <br>
226  *        get the first object of a specific data type
227  * - @ref GetNextInputObject <br>
228  *        get the next object of same data type as last GetFirstInputObject/Block call
229  * - @ref GetFirstInputBlock <br>
230  *        get the first block of a specific data type
231  * - @ref GetNextInputBlock <br>
232  *        get the next block of same data type as last GetFirstInputBlock/Block call
233  * - @ref PushBack <br>
234  *        insert an object or data buffer into the output
235  * - @ref CreateEventDoneData <br>
236  *        add event information to the output
237  * 
238  * In addition, the processing methods are simplified a bit by cutting out most of
239  * the parameters.
240  * @see 
241  * - @ref AliHLTProcessor::DoEvent
242  * - @ref AliHLTDataSource::GetEvent
243  * - @ref AliHLTDataSink::DumpEvent
244  *
245  * \em IMPORTANT: objects and block descriptors provided by the high-level interface
246  *  <b>MUST NOT BE DELETED</b> by the caller.
247  *
248  * @subsubsection alihltcomponent-high-level-int-guidelines High-level interface guidelines
249  * - Structures must inherit from the ROOT object base class TObject in order be 
250  * transported by the transportation framework.
251  * - all pointer members must be transient (marked <tt>//!</tt> behind the member
252  * definition), i.e. will not be stored/transported, or properly marked
253  * (<tt>//-></tt>) in order to call the streamer of the object the member is pointing
254  * to. The latter is not recomended. Structures to be transported between components
255  * should be streamlined.
256  * - no use of stl vectors/strings, use appropriate ROOT classes instead 
257  * 
258  * @subsection alihltcomponent-low-level-interface Low-level interface
259  * The low-level component interface consists of the specific data processing
260  * methods for @ref AliHLTProcessor, @ref AliHLTDataSource, and @ref AliHLTDataSink.
261  * - @ref AliHLTProcessor::DoEvent
262  * - @ref AliHLTDataSource::GetEvent
263  * - @ref AliHLTDataSink::DumpEvent
264  * 
265  * The base class passes all relevant parameters for data access directly on to the
266  * component. Input blocks can be accessed by means of the array <tt> blocks </tt>.
267  * Output data are written directly to shared memory provided by the pointer
268  * <tt> outputPtr </tt> and output block descriptors are inserted directly to the
269  * list <tt> outputBlocks </tt>.
270  *
271  * \b NOTE: The high-level input data access methods can be used also from the low
272  * level interface. Also the PushBack functions can be used BUT ONLY if no data is
273  * written to the output buffer and no data block descriptors are inserted into the
274  * output block list.
275  *
276  * @section alihltcomponent-initialization Component initialization and configuration
277  * The component interface provides two optional methods for component initialization
278  * and configuration. The @ref DoInit function is called once before the processing.
279  * During the event processing, a special event can trigger a reconfiguration and the
280  * @ref Reconfigure method is called. There are three possible options of initialization
281  * and configuration:
282  * - default values: set directly in the source code
283  * - OCDB objects: all necessary information must be loaded from OCDB objects. The
284  *   Offline Conditions Data Base stores objects specifically valid for individual runs
285  *   or run ranges.
286  * - Component arguments: can be specified for every component in the chain
287  *   configuration. The arguments can be used to override specific parameters of the
288  *   component.
289  *
290  * As a general rule, the three options should be processed in that sequence, i.e
291  * default parameters might be overridden by OCDB configuration, and the latter one
292  * by component arguments.
293  *
294  * @subsection alihltcomponent-initialization-arguments Component arguments
295  * In normal operation, components are supposed to run without any additional argument,
296  * however such arguments can be useful for testing and debugging. The idea follows
297  * the format of command line arguments. A keyword is indicated by a dash and an
298  * optional argument might follow, e.g.:
299  * <pre>
300  * -argument1 0.5 -argument2
301  * </pre>
302  * In this case argument1 requires an additional parameter whereas argument2 does not.
303  * The arguments will be provided as an array of separated arguments.
304  *
305  * Component arguments can be classified into initialization arguments and configuration
306  * arguments. The latter are applicable for both the @ref DoInit and @ref Reconfigure
307  * method whereas initialization arguments are not applicable after DoInit.
308  *
309  * @subsection alihltcomponent-initialization-ocdb OCDB objects
310  * OCDB objects are ROOT <tt>TObjects</tt> and can be of any type. This is in particular
311  * useful for complex parameter sets. However in most cases, a simple approach of human
312  * readable command line arguments is appropriate. Such a string can be simply stored
313  * in a TObjString (take note that the TString does not derive from TObject). The
314  * same arguments as for the command line can be used. Take note that in the TObjString
315  * all arguments are separated by blanks, instead of being in an array of separate
316  * strings.
317  *
318  * The base class provides two functions regarding OCDB objects: 
319  * - LoadAndExtractOCDBObject() loads the OCDB entry for the specified path and extracts
320  *                              the TObject from it. An optional key allows to access
321  *                              a TObject within a TMap
322  * - ConfigureFromCDBTObjString() can load a number of OCDB objects and calls the
323  *                              argument parsing ConfigureFromArgumentString
324  *
325  *
326  * @subsection alihltcomponent-initialization-sequence Initialization sequence
327  * Using the approach of <tt>TObjString</tt>-type configuration objects allows to treat
328  * configuration from both @ref DoInit and @ref Reconfigure in the same way.
329  *
330  * The base class provides the function ConfigureFromArgumentString() which loops over
331  * all arguments and calls the child's method ScanConfigurationArgument(). Here the
332  * actual treatment of the argument and its parameters needs to be implemented.
333  * ConfigureFromArgumentString() can treat both arrays of arguments and arguments in
334  * one single string separated by blanks. The two options can be mixed.
335  *
336  * A second base class function ConfigureFromCDBTObjString() allows to configure
337  * directly from a number of OCDB objects. This requires the entries to be of
338  * type TObjString and the child implementation of ScanConfigurationArgument().
339  * The object can also be of type TMap with TObjStrings as key-value pairs. The
340  * key identifier can be chosen by the component implementation. Normally it will
341  * be the run type ("p","A-A", "p-A", ...) or e.g. the trigger code secified by
342  * ECS.
343  *
344  * @section alihltcomponent-handling Component handling 
345  * The handling of HLT analysis components is carried out by the AliHLTComponentHandler.
346  * Component are registered automatically at load-time of the component shared library
347  * under the following suppositions:
348  * - the component library has to be loaded from the AliHLTComponentHandler using the
349  *   @ref AliHLTComponentHandler::LoadLibrary method.
350  * - the library defines an AliHLTModuleAgent which registers all components.
351  *   See AliHLTModuleAgent::RegisterComponents                               <br>
352  *     or                                                                    <br>
353  * - the component implementation defines one global object (which is generated
354  *   when the library is loaded)                                             <br>
355  *
356  * @subsection alihltcomponent-design-rules General design considerations
357  * The analysis code should be implemented in one or more destict class(es). A 
358  * \em component should be implemented which interface the destict analysis code to the
359  * component interface. This component generates the analysis object dynamically. <br>
360  *
361  * Assume you have an implemetation <tt> AliHLTDetMyAnalysis </tt>, another class <tt>
362  * AliHLTDetMyAnalysisComponent </tt> contains:
363  * <pre>
364  * private:
365  *   AliHLTDetMyAnalysis* fMyAnalysis;  //!
366  * </pre>
367  * The object should then be instantiated in the DoInit handler of 
368  * <tt>AliHLTDetMyAnalysisComponent </tt>, and cleaned in the DoDeinit handler.
369  *
370  * Further rules:
371  * - avoid big static arrays in the component, allocate the memory at runtime
372  * - allocate all kind of complex data members (like classes, ROOT TObjects of
373  *   any kind) dynamically in DoInit and clean up in DoDeinit
374  *
375  * @section alihlt_component_arguments Default arguments
376  * The component base class provides some default arguments:
377  * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting -->
378  * \li -loglevel=level     <br>
379  * \li -object-compression=level     <br>
380  *      compression level for ROOT objects, default is defined by
381  *      @ref ALIHLTCOMPONENT_DEFAULT_OBJECT_COMPRESSION
382  * \li -pushback-period=period     <br>
383  *      scale down for PushBack of objects, shipped only for one event
384  *      every <i>period</i> seconds
385  *
386  * @ingroup alihlt_component
387  * @section alihltcomponent-members Class members
388  */
389 class AliHLTComponent : public AliHLTLogging {
390  public:
391   /** standard constructor */
392   AliHLTComponent();
393   /** standard destructor */
394   virtual ~AliHLTComponent();
395
396   /** component type definitions */
397   enum TComponentType { kUnknown=0, kSource=1, kProcessor=2, kSink=3 };
398
399   /**
400    * Init function to prepare data processing.
401    * Initialization of common data structures for a sequence of events.
402    * The call is redirected to the internal method DoInit which can be
403    * overridden by the child class.
404    * During Init also the environment structure is passed to the component.
405    * @param comenv         environment pointer with environment dependent function
406    *                       calls
407    * @param environParam   additional parameter for function calls, the pointer
408    *                       is passed as it is
409    * @param argc           size of the argument array
410    * @param argv           augment array for component initialization
411    */
412   virtual int Init( const AliHLTAnalysisEnvironment* comenv, void* environParam, int argc, const char** argv );
413
414   /**
415    * Clean-up function to terminate data processing.
416    * Clean-up of common data structures after data processing.
417    * The call is redirected to the internal method @ref DoDeinit which can be
418    * overridden by the child class.
419    */
420   virtual int Deinit();
421
422   /**
423    * Processing of one event.
424    * The method is the entrance of the event processing. The parameters are
425    * cached for uses with the high-level interface and the DoProcessing
426    * implementation is called.
427    *
428    * @param evtData
429    * @param blocks
430    * @param trigData
431    * @param outputPtr
432    * @param size
433    * @param outputBlockCnt  out: size of the output block array, set by the component
434    * @param outputBlocks    out: the output block array is allocated internally
435    * @param edd
436    * @return neg. error code if failed
437    */
438   int ProcessEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
439                             AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
440                             AliHLTUInt32_t& size, AliHLTUInt32_t& outputBlockCnt, 
441                             AliHLTComponentBlockData*& outputBlocks,
442                             AliHLTComponentEventDoneData*& edd );
443
444   /**
445    * Internal processing of one event.
446    * The method is pure virtual and implemented by the child classes 
447    * - @ref AliHLTProcessor
448    * - @ref AliHLTDataSource
449    * - @ref AliHLTDataSink
450    *
451    * @param evtData
452    * @param blocks
453    * @param trigData
454    * @param outputPtr
455    * @param size
456    * @param outputBlocks    out: the output block array is allocated internally
457    * @param edd
458    * @return neg. error code if failed
459    */
460   virtual int DoProcessing( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
461                             AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
462                             AliHLTUInt32_t& size,
463                             AliHLTComponentBlockDataList& outputBlocks,
464                             AliHLTComponentEventDoneData*& edd ) = 0;
465
466   /**
467    * Init the CDB.
468    * The function must not be called when running in AliRoot unless it it
469    * really wanted. The CDB path will be set to the specified path, which might
470    * override the path initialized at the beginning of the AliRoot reconstruction.
471    *
472    * The method is used from the external interface in order to set the correct
473    * path when running on-line. The function also initializes the function
474    * callback for setting the run no during operation.
475    *
476    * A separation of library and component handling is maybe appropriate in the
477    * future. Using the global component handler here is maybe not the cleanest
478    * solution.
479    * @param cdbPath      path of the CDB
480    * @param pHandler     the component handler used for llibrary handling.
481    */
482   int InitCDB(const char* cdbPath, AliHLTComponentHandler* pHandler);
483
484   /**
485    * Set the run no for the CDB.
486    * The function must not be called when running in AliRoot unless it it
487    * really wanted. The CDB path will be set to the specified path, which might
488    * override the run no initialized at the beginning of the AliRoot reconstruction.
489    * InitCDB() has to be called before in order to really change the CDB settings.
490    *
491    * The method is used from the external interface in order to set the correct
492    * path when running on-line.
493    */
494   int SetCDBRunNo(int runNo);
495
496   /**
497    * Set the run description.
498    * The run description is set before the call of Init() -> DoInit().
499    * @note: This functionality has been added in Juli 2008. The transmission of
500    * run properties by a special SOR (SOD event in DAQ terminalogy but this was
501    * changed after the HLT interface was designed) event is not sufficient because
502    * the data might be needed already in the DoInit handler of the component.
503    * @param desc    run descriptor, currently only the run no member is used
504    * @param runType originally, run type was supposed to be a number and part
505    *                of the run descriptor. But it was defined as string later
506    */
507   int SetRunDescription(const AliHLTRunDesc* desc, const char* runType);
508
509   /**
510    * Set the component description.
511    * The description string can contain tokens separated by blanks, a token
512    * consists of a key and an optional value separated by '='.
513    * Possible keys:
514    * \li -chainid=id        string id within the chain of the instance
515    *
516    * @param desc    component description
517    */
518   int SetComponentDescription(const char* desc);
519
520   /**
521    * Set the running environment for the component.
522    * Originally, the environment was set in the Init function. However, the setup of
523    * the CDB is required before. In order to have proper logging functionality, the
524    * environment is required.
525    * @param comenv         environment pointer with environment dependent function
526    *                       calls
527    * @param environParam   additional parameter for function calls, the pointer
528    *                       is passed as it is
529    */
530   int SetComponentEnvironment(const AliHLTAnalysisEnvironment* comenv, void* environParam);
531
532   // Information member functions for registration.
533
534   /**
535    * Get the type of the component.
536    * The function is pure virtual and must be implemented by the child class.
537    * @return component type id
538    */
539   virtual TComponentType GetComponentType() = 0; // Source, sink, or processor
540
541   /**
542    * Get the id of the component.
543    * Each component is identified by a unique id.
544    * The function is pure virtual and must be implemented by the child class.
545    * @return component id (string)
546    */
547   virtual const char* GetComponentID() = 0;
548
549   /**
550    * Get the input data types of the component.
551    * The function is pure virtual and must be implemented by the child class.
552    * @return list of data types in the vector reference
553    */
554   virtual void GetInputDataTypes( AliHLTComponentDataTypeList& ) = 0;
555
556   /**
557    * Get the output data type of the component.
558    * The function is pure virtual and must be implemented by the child class.
559    * @return output data type
560    */
561   virtual AliHLTComponentDataType GetOutputDataType() = 0;
562
563   /**
564    * Get the output data types of the component.
565    * The function can be implemented to indicate multiple output data types
566    * in the target array.
567    * @ref GetOutputDataType must return @ref kAliHLTMultipleDataType in order
568    * to invoke this method.
569    * @param tgtList          list to receive the data types
570    * @return no of output data types, data types in the target list
571    */
572   virtual int GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList);
573
574   /**
575    * Get a ratio by how much the data volume is shrunken or enhanced.
576    * The function is pure virtual and must be implemented by the child class.
577    * @param constBase        <i>return</i>: additive part, independent of the
578    *                                   input data volume  
579    * @param inputMultiplier  <i>return</i>: multiplication ratio
580    * @return values in the reference variables
581    */
582   virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) = 0;
583
584   /**
585    * Get a list of OCDB object description.
586    * The list of objects is provided in a TMap
587    * - key: complete OCDB path, e.g. GRP/GRP/Data
588    * - value: short description why the object is needed
589    * Key and value objects created inside this class go into ownership of
590    * target TMap.
591    * @param targetMap   TMap instance receiving the list
592    * @return void
593    */
594   virtual void GetOCDBObjectDescription( TMap* const targetArray);
595
596   /**
597    * Spawn function.
598    * Each component must implement a spawn function to create a new instance of 
599    * the class. Basically the function must return <i>new <b>my_class_name</b></i>.
600    * @return new class instance
601    */
602   virtual AliHLTComponent* Spawn() = 0;
603
604   /**
605    * check the availability of the OCDB entry descriptions in the TMap
606    *  key : complete OCDB path of the entry
607    *  value : auxiliary object - short description
608    * if the external map was not provided the function invokes
609    * interface function GetOCDBObjectDescription() to retrieve the list.
610    * @param externList  map of entries to be tested
611    * @result 0 if all found, -ENOENT if objects not found
612    */
613   int CheckOCDBEntries(const TMap* const externList=NULL);
614
615   /**
616    * Find matching data types between this component and a consumer component.
617    * Currently, a component can produce only one type of data. This restriction is most
618    * likely to be abolished in the future.
619    * @param pConsumer a component and consumer of the data produced by this component
620    * @param tgtList   reference to a vector list to receive the matching data types.
621    * @return >= 0 success, neg. error code if failed
622    */ 
623   int FindMatchingDataTypes(AliHLTComponent* pConsumer, AliHLTComponentDataTypeList* tgtList);
624  
625   /**
626    * Set the global component handler.
627    * The static method is needed for the automatic registration of components. 
628    */
629   static int SetGlobalComponentHandler(AliHLTComponentHandler* pCH, int bOverwrite=0);
630
631   /**
632    * Clear the global component handler.
633    * The static method is needed for the automatic registration of components. 
634    */
635   static int UnsetGlobalComponentHandler();
636
637   /**
638    * Helper function to convert the data type to a string.
639    * @param type        data type structure
640    * @param mode        0 print string origin:type          <br>
641    *                    1 print chars                       <br>
642    *                    2 print numbers                     <br>
643    *                    3 print 'type' 'origin' 
644    */
645   static string DataType2Text( const AliHLTComponentDataType& type, int mode=0);
646
647   /**
648    * Calculate a CRC checksum of a data buffer.
649    * Polynomial for the calculation is 0xD8.
650    */
651   static AliHLTUInt32_t CalculateChecksum(const AliHLTUInt8_t* buffer, int size);
652
653   /**
654    * Helper function to print content of data type.
655    */
656   static void PrintDataTypeContent(AliHLTComponentDataType& dt, const char* format=NULL);
657
658   /**
659    * helper function to initialize AliHLTComponentEventData structure
660    */
661   static void FillEventData(AliHLTComponentEventData& evtData);
662
663   /**
664    * Print info on an AliHLTComponentDataType structure
665    * This is just a helper function to examine an @ref AliHLTComponentDataType
666    * structur.
667    */
668   static void PrintComponentDataTypeInfo(const AliHLTComponentDataType& dt);
669
670   /**
671    * Fill AliHLTComponentBlockData structure with default values.
672    * @param blockData   reference to data structure
673    */
674   static void FillBlockData( AliHLTComponentBlockData& blockData );
675
676   /**
677    * Fill AliHLTComponentShmData structure with default values.
678    * @param shmData   reference to data structure
679    */
680   static void FillShmData( AliHLTComponentShmData& shmData );
681
682   /**
683    * Fill AliHLTComponentDataType structure with default values.
684    * @param dataType   reference to data structure
685    */
686   static void FillDataType( AliHLTComponentDataType& dataType );
687   
688   /**
689    * Copy data type structure
690    * Copies the value an AliHLTComponentDataType structure to another one
691    * @param[out] tgtdt   target structure
692    * @param[in] srcdt   source structure
693    */
694   static void CopyDataType(AliHLTComponentDataType& tgtdt, const AliHLTComponentDataType& srcdt);
695
696   /**
697    * Set the ID and Origin of an AliHLTComponentDataType structure.
698    * The function sets the fStructureSize member and copies the strings
699    * to the ID and Origin. Only characters from the valid part of the string
700    * are copied, the rest is filled with 0's. <br>
701    * Please note that the fID and fOrigin members are not strings, just arrays of
702    * chars of size @ref kAliHLTComponentDataTypefIDsize and
703    * @ref kAliHLTComponentDataTypefOriginSize respectively and not necessarily with
704    * a terminating zero. <br>
705    * It is possible to pass NULL pointers as id or origin argument, in that case they
706    * are just ignored.
707    * @param tgtdt   target data type structure
708    * @param id      ID string
709    * @param origin  Origin string
710    */
711   static void SetDataType(AliHLTComponentDataType& tgtdt, const char* id, const char* origin);
712
713   /**
714    * Set the ID and Origin of an AliHLTComponentDataType structure.
715    * Given the fact that the data type ID is 64bit wide and origin 32, this helper
716    * function sets the data type from those two parameters.
717    * @param dt      target data type structure
718    * @param id      64bit id
719    * @param orig    32bit origin
720    */
721   static void SetDataType(AliHLTComponentDataType& dt, AliHLTUInt64_t id, AliHLTUInt32_t orig); 
722
723   /**
724    * Extract a component table entry from the payload buffer.
725    * The entry consists of the AliHLTComponentTableEntry structure, the array of
726    * parents and a description string of the format 'chain-id{component-id:component-args}'.
727    * The function fills all the variables after a consistency check.
728    */
729   static int ExtractComponentTableEntry(const AliHLTUInt8_t* pBuffer, AliHLTUInt32_t size,
730                                         string& chainId, string& compId, string& compParam,
731                                         vector<AliHLTUInt32_t>& parents);
732
733   /**
734    * Extracts the different data parts from the trigger data structure.
735    * [in] @param trigData  The trigger data as passed to the DoProcessing method.
736    * [out] @param attributes  The data block attributes given by the HLT framework.
737    * [out] @param status  The HLT status bits given by the HLT framework.
738    * [out] @param cdh  The common data header received from DDL links.
739    * [out] @param readoutlist  The readout list to fill with readout list bits
740    *                           passed on by the HLT framework.
741    * [in] @param printErrors  If true then error messages are generated as necessary
742    *                          and suppressed otherwise.
743    * @note If any of the output parameters are set to NULL then the field is not set.
744    *   For example, the following line will only fill the CDH pointer.
745    *   \code
746    *     AliRawDataHeader* cdh;
747    *     ExtractTriggerData(trigData, NULL, NULL, &cdh, NULL);
748    *   \endcode
749    * @return zero on success or one of the following error codes on failure.
750    *   if a non-zero error code is returned then none of the output parameters are
751    *   modified.
752    *    \li -ENOENT  The <i>trigData</i> structure size is wrong.
753    *    \li -EBADF   The <i>trigData</i> data size is wrong.
754    *    \li -EBADMSG The common data header (CDH) in the trigger data has the wrong
755    *                 number of words indicated.
756    *    \li -EPROTO  The readout list structure in the trigger data has the wrong
757    *                 number of words indicated.
758    */
759   static int ExtractTriggerData(
760       const AliHLTComponentTriggerData& trigData,
761       const AliHLTUInt8_t (**attributes)[gkAliHLTBlockDAttributeCount],
762       AliHLTUInt64_t* status,
763       const AliRawDataHeader** cdh,
764       AliHLTReadoutList* readoutlist,
765       bool printErrors = false
766     );
767
768   /**
769    * Extracts the readout list from a trigger data structure.
770    * [in] @param trigData  The trigger data as passed to the DoProcessing method.
771    * [out] @param list  The output readout list to fill.
772    * [in] @param printErrors  If true then error messages are generated as necessary
773    *                          and suppressed otherwise.
774    * @return zero on success or one of the error codes returned by ExtractTriggerData.
775    */
776   static int GetReadoutList(
777       const AliHLTComponentTriggerData& trigData, AliHLTReadoutList& list,
778       bool printErrors = false
779     )
780   {
781     return ExtractTriggerData(trigData, NULL, NULL, NULL, &list, printErrors);
782   }
783
784   /**
785    * Extracts the event type from the given Common Data Header.
786    * [in] @param cdh  The Common Data Header to extract the event type from.
787    * @return the event type code from the CDH.
788    */
789   static AliHLTUInt32_t ExtractEventTypeFromCDH(const AliRawDataHeader* cdh);
790   
791   /**
792    * Stopwatch type for benchmarking.
793    */
794   enum AliHLTStopwatchType {
795     /** total time for event processing */
796     kSWBase,
797     /** detector algorithm w/o interface callbacks */
798     kSWDA,
799     /** data sources */
800     kSWInput,
801     /** data sinks */
802     kSWOutput,
803     /** number of types */
804     kSWTypeCount
805   };
806
807   /**
808    * Helper class for starting and stopping a stopwatch.
809    * The guard can be used by instantiating an object in a function. The
810    * specified stopwatch is started and the previous stopwatch put on
811    * hold. When the function is terminated, the object is deleted automatically
812    * deleted, stopping the stopwatch and starting the one on hold.<br>
813    * \em IMPORTANT: never create dynamic objects from this guard as this violates
814    * the idea of a guard.
815    */
816   class AliHLTStopwatchGuard {
817   public:
818     /** standard constructor (not for use) */
819     AliHLTStopwatchGuard();
820     /** constructor */
821     AliHLTStopwatchGuard(TStopwatch* pStart);
822     /** copy constructor (not for use) */
823     AliHLTStopwatchGuard(const AliHLTStopwatchGuard&);
824     /** assignment operator (not for use) */
825     AliHLTStopwatchGuard& operator=(const AliHLTStopwatchGuard&);
826     /** destructor */
827     ~AliHLTStopwatchGuard();
828
829   private:
830     /**
831      * Hold the previous guard for the existence of this guard.
832      * Checks whether this guard controls a new stopwatch. In that case, the
833      * previous guard and its stopwatch are put on hold.
834      * @param pSucc        instance of the stopwatch of the new guard
835      * @return    1 if pSucc is a different stopwatch which should
836      *            be started<br>
837      *            0 if it controls the same stopwatch
838      */
839     int Hold(const TStopwatch* pSucc);
840
841     /**
842      * Resume the previous guard.
843      * Checks whether the peceeding guard controls a different stopwatch. In that
844      * case, the its stopwatch is resumed.
845      * @param pSucc        instance of the stopwatch of the new guard
846      * @return    1 if pSucc is a different stopwatch which should
847      *            be stopped<br>
848      *            0 if it controls the same stopwatch
849      */
850     int Resume(const TStopwatch* pSucc);
851
852     /** the stopwatch controlled by this guard */
853     TStopwatch* fpStopwatch;                                                //!transient
854
855     /** previous stopwatch guard, put on hold during existence of the guard */
856     AliHLTStopwatchGuard* fpPrec;                                           //!transient
857
858     /** active stopwatch guard */
859     static AliHLTStopwatchGuard* fgpCurrent;                                //!transient
860   };
861
862   /**
863    * Set a stopwatch for a given purpose.
864    * @param pSW         stopwatch object
865    * @param type        type of the stopwatch
866    */
867   int SetStopwatch(TObject* pSW, AliHLTStopwatchType type=kSWBase);
868
869   /**
870    * Init a set of stopwatches.
871    * @param pStopwatches object array of stopwatches
872    */
873   int SetStopwatches(TObjArray* pStopwatches);
874
875   /**
876    * Customized logging function.
877    * The chain id, component id and pointer is added at the beginning of each message.
878    */
879   int LoggingVarargs(AliHLTComponentLogSeverity severity, 
880                      const char* originClass, const char* originFunc,
881                      const char* file, int line, ... ) const;
882
883   /**
884    * Get size of last serialized object.
885    * During PushBack, TObjects are serialized in a separate buffer. The
886    * size of the last object can be retrieved by this function.
887    *
888    * This might be especially useful for PushBack failures caused by too
889    * small output buffer.
890    */
891   int GetLastObjectSize() const {return fLastObjectSize;}
892
893   /**
894    * This method generates a V4 Globally Unique Identifier (GUID) using the
895    * ROOT TRandom3 pseudo-random number generator with the process' UID, GID
896    * PID and host address as seeds. For good measure MD5 sum hashing is also
897    * applied.
898    * @return the newly generated GUID structure.
899    */
900   static TUUID GenerateGUID();
901
902  protected:
903
904   /**
905    * Default method for the internal initialization.
906    * The method is called by @ref Init
907    */
908   virtual int DoInit( int argc, const char** argv );
909
910   /**
911    * Default method for the internal clean-up.
912    * The method is called by @ref Deinit
913    */
914   virtual int DoDeinit();
915
916   /**
917    * Reconfigure the component.
918    * The method is called when an event of type @ref kAliHLTDataTypeComConf
919    * {COM_CONF:PRIV} is received by the component. If the event is sent as
920    * part of a normal event, the component configuration is called first.
921    *
922    * The CDB path parameter specifies the path in the CDB, i.e. without
923    * leading absolute path of the CDB location. The framework might also
924    * provide the id of the component in the analysis chain.
925    *
926    * The actual sequence of configuration depends on the component. As a
927    * general rule, the component should load the specific OCDB object if
928    * provided as parameter, and load the default objects if the parameter
929    * is NULL. However, other schemes are possible. See @ref 
930    *
931    * \b Note: The CDB will be initialized by the framework, either already set
932    * from AliRoot or from the wrapper interface during initialization.
933    *
934    * @param cdbEntry     path of the cdbEntry
935    * @param chainId      the id/name of the component in the current analysis
936    *                     chain. This is not necessarily the same as what is
937    *                     returned by the GetComponentID() method.
938    * @note both parameters can be NULL, check before usage
939    */
940   virtual int Reconfigure(const char* cdbEntry, const char* chainId);
941
942   /**
943    * Read the Preprocessor values.
944    * The function is invoked when the component is notified about available/
945    * updated data points from the detector Preprocessors. The 'modules'
946    * argument contains all detectors for which the Preprocessors have
947    * updated data points. The component has to implement the CDB access to
948    * get the desired data points.
949    * @param modules     detectors for which the Preprocessors have updated
950    *                    data points: TPC, TRD, ITS, PHOS, MUON, or ALL if
951    *                    no argument was received.
952    * @return neg. error code if failed
953    */
954   virtual int ReadPreprocessorValues(const char* modules);
955
956   /**
957    * Child implementation to scan a number of configuration arguments.
958    * The method is invoked by the framework in conjunction with the
959    * common framework functions ConfigureFromArgumentString and
960    * ConfigureFromCDBTObjString.
961    * Function needs to scan the argument and optional additional
962    * parameters and returns the number of elements in the array which
963    * have been treated.
964    * @param argc
965    * @param argv
966    * @return number of arguments which have been scanned or neg error
967    *         code if failed                                              <br>
968    *         \li -EINVAL      unknown argument
969    *         \li -EPROTO      protocol error, e.g. missing parameter
970    */
971   virtual int ScanConfigurationArgument(int argc, const char** argv);
972
973   /**
974    * Custom handler for the SOR event.
975    * Is invoked from the base class if an SOR event is in the block list.
976    * The handler is called before the processing function. The processing
977    * function is skipped if there are no other data blocks available.
978    *
979    * The SOR event is generated by the PubSub framework in response to
980    * the DAQ start of data (SOD - has been renamed after HLT interface
981    * was designed). The SOD event consists of 3 blocks:
982    * - ::kAliHLTDataTypeEvent block: spec ::gkAliEventTypeStartOfRun
983    * - SOD block of type ::kAliHLTDataTypeSOR, payload: AliHLTRunDesc struct
984    * - run type block ::kAliHLTDataTypeRunType, payload: run type string 
985    *
986    * Run properties can be retrieved by getters like GetRunNo().
987    * @return neg. error code if failed
988    */
989   virtual int StartOfRun();
990
991   /**
992    * Custom handler for the EOR event.
993    * Is invoked from the base class if an EOR event is in the block list.
994    * The handler is called before the processing function. The processing
995    * function is skipped if there are no other data blocks available.
996    *
997    * See StartOfRun() for more comments of the sequence of steering events.
998    *
999    * @return neg. error code if failed
1000    */
1001   virtual int EndOfRun();
1002
1003   /**
1004    * Check whether a component requires all steering blocks.
1005    * Childs can overload in order to indicate that they want to
1006    * receive also the steering data blocks. There is also the
1007    * possibility to add the required data types to the input
1008    * data type list in GetInputDataTypes().
1009    */
1010   virtual bool RequireSteeringBlocks() const {return false;}
1011
1012   /**
1013    * General memory allocation method.
1014    * All memory which is going to be used 'outside' of the interface must
1015    * be provided by the framework (online or offline).
1016    * The method is redirected to a function provided by the current
1017    * framework. Function pointers are transferred via the @ref
1018    * AliHLTAnalysisEnvironment structure.
1019    */
1020   void* AllocMemory( unsigned long size );
1021
1022   /**
1023    * Helper function to create a monolithic BlockData description block out
1024    * of a list BlockData descriptors.
1025    * For convenience, inside the interface vector lists are used, to make the
1026    * interface pure C style, monilithic blocks must be exchanged. 
1027    * The method is redirected to a function provided by the current
1028    * framework. Function pointers are transferred via the @ref
1029    * AliHLTAnalysisEnvironment structure.
1030    */
1031   int MakeOutputDataBlockList( const AliHLTComponentBlockDataList& blocks, AliHLTUInt32_t* blockCount,
1032                                AliHLTComponentBlockData** outputBlocks );
1033
1034   /**
1035    * Fill the EventDoneData structure.
1036    * The method is redirected to a function provided by the current
1037    * framework. Function pointers are transferred via the @ref
1038    * AliHLTAnalysisEnvironment structure.
1039    */
1040   int GetEventDoneData( unsigned long size, AliHLTComponentEventDoneData** edd ) const;
1041
1042   /**
1043    * Allocate an EventDoneData structure for the current event .
1044    * The method allocates the memory internally and does not interact with the current Framework.
1045    * The allocated data structure is empty initially and can be filled by calls to the 
1046    * @ref PushEventDoneData method. The memory will be automatically released after the event has been processed.
1047    * 
1048    */
1049   int ReserveEventDoneData( unsigned long size );
1050
1051   /**
1052    * Push a 32 bit word of data into event done data for the current event which
1053    * has previously been allocated by the @ref ReserveEventDoneData method.
1054    */
1055   int PushEventDoneData( AliHLTUInt32_t eddDataWord );
1056
1057   /**
1058    * Release event done data previously reserved by @ref ReserveEventDoneData
1059    */
1060    void ReleaseEventDoneData();
1061
1062   /**
1063    * Get the pointer to the event done data available/built so far for the current event via
1064    * @ref ReserveEventDoneData and @ref PushEventDoneData
1065    */
1066   AliHLTComponentEventDoneData* GetCurrentEventDoneData() const
1067     {
1068     return fEventDoneData;
1069     }
1070
1071   /**
1072    * Helper function to convert the data type to a string.
1073    */
1074   void DataType2Text(const AliHLTComponentDataType& type, char output[kAliHLTComponentDataTypefIDsize+kAliHLTComponentDataTypefOriginSize+2]) const;
1075
1076   /**
1077    * Loop through a list of component arguments.
1078    * The list can be either an array of separated strings or one single
1079    * string containing blank separated arguments, or both mixed.
1080    * ScanConfigurationArgument() is called to allow the component to treat
1081    * the individual arguments.
1082    * @return neg. error code if failed
1083    */
1084   int ConfigureFromArgumentString(int argc, const char** argv);
1085
1086   /**
1087    * Read configuration objects from OCDB and configure from
1088    * the content of TObjString entries.
1089    * @param entries   blank separated list of OCDB paths
1090    * @param key       if the entry is a TMap, search for the corresponding object
1091    * @return neg. error code if failed
1092    */
1093   int ConfigureFromCDBTObjString(const char* entries, const char* key=NULL);
1094
1095   /**
1096    * Load specified entry from the OCDB and extract the object.
1097    * The entry is explicitely unloaded from the cache before it is loaded.
1098    * If parameter key is specified the OCDB object is treated as TMap
1099    * and the TObject associated with 'key' is loaded.
1100    * @param path      path of the entry under to root of the OCDB
1101    * @param version   version of the entry
1102    * @param subVersion  subversion of the entry
1103    * @param key       key of the object within TMap
1104    */
1105   TObject* LoadAndExtractOCDBObject(const char* path, int version = -1, int subVersion = -1, const char* key=NULL);
1106
1107   TObject* LoadAndExtractOCDBObject(const char* path, const char* key) {
1108     return LoadAndExtractOCDBObject(path, -1, -1, key);
1109   }
1110
1111   /**
1112    * Get event number.
1113    * @return value of the internal event counter
1114    */
1115   int GetEventCount() const;
1116
1117   /**
1118    * Get the number of input blocks.
1119    * @return number of input blocks
1120    */
1121   int GetNumberOfInputBlocks() const;
1122
1123   /**
1124    * Get id of the current event
1125    * @return event id
1126    */
1127   AliHLTEventID_t GetEventId() const;
1128
1129   /**
1130    * Get the first object of a specific data type from the input data.
1131    * The High-level methods provide functionality to transfer ROOT data
1132    * structures which inherit from TObject.
1133    *
1134    * The method looks for the first ROOT object of type dt in the input stream.
1135    * If also the class name is provided, the object is checked for the right
1136    * class type. The input data block needs a certain structure, namely the 
1137    * buffer size as first word. If the cross check fails, the retrieval is
1138    * silently abandoned, unless the \em bForce parameter is set.<br>
1139    * \b Note: THE OBJECT MUST NOT BE DELETED by the caller.
1140    *
1141    * If called without parameters, the function tries to create objects from
1142    * all available input blocks, also the ones of data type kAliHLTVoidDataType
1143    * which are not matched by kAliHLTAnyDataType.
1144    *
1145    * @param dt          data type of the object
1146    * @param classname   class name of the object
1147    * @param bForce      force the retrieval of an object, error messages
1148    *                    are suppressed if \em bForce is not set
1149    * @return pointer to @ref TObject, NULL if no objects of specified type
1150    *         available
1151    */
1152   const TObject* GetFirstInputObject(const AliHLTComponentDataType& dt=kAliHLTAllDataTypes,
1153                                      const char* classname=NULL,
1154                                      int bForce=0);
1155
1156   /**
1157    * Get the first object of a specific data type from the input data.
1158    * The High-level methods provide functionality to transfer ROOT data
1159    * structures which inherit from TObject.
1160    * The method looks for the first ROOT object of type specified by the ID and 
1161    * Origin strings in the input stream.
1162    * If also the class name is provided, the object is checked for the right
1163    * class type. The input data block needs a certain structure, namely the 
1164    * buffer size as first word. If the cross check fails, the retrieval is
1165    * silently abandoned, unless the \em bForce parameter is set.<br>
1166    * \em Note: THE OBJECT MUST NOT BE DELETED by the caller.
1167    * @param dtID        data type ID of the object
1168    * @param dtOrigin    data type origin of the object
1169    * @param classname   class name of the object
1170    * @param bForce      force the retrieval of an object, error messages
1171    *                    are suppressed if \em bForce is not set
1172    * @return pointer to @ref TObject, NULL if no objects of specified type
1173    *         available
1174    */
1175   const TObject* GetFirstInputObject(const char* dtID, 
1176                                      const char* dtOrigin,
1177                                      const char* classname=NULL,
1178                                      int bForce=0);
1179
1180   /**
1181    * Get the next object of a specific data type from the input data.
1182    * The High-level methods provide functionality to transfer ROOT data
1183    * structures which inherit from TObject.
1184    * The method looks for the next ROOT object of type and class specified
1185    * to the previous @ref GetFirstInputObject call.<br>
1186    * \em Note: THE OBJECT MUST NOT BE DELETED by the caller.
1187    * @param bForce      force the retrieval of an object, error messages
1188    *                    are suppressed if \em bForce is not set
1189    * @return pointer to @ref TObject, NULL if no more objects available
1190    */
1191   const TObject* GetNextInputObject(int bForce=0);
1192
1193   /**
1194    * Get data type of an input block.
1195    * Get data type of the object previously fetched via
1196    * GetFirstInputObject/NextInputObject or the last one if no object
1197    * specified.
1198    * @param pObject     pointer to TObject
1199    * @return data specification, kAliHLTVoidDataSpec if failed
1200    */
1201   AliHLTComponentDataType GetDataType(const TObject* pObject=NULL);
1202
1203   /**
1204    * Get data specification of an input block.
1205    * Get data specification of the object previously fetched via
1206    * GetFirstInputObject/NextInputObject or the last one if no object
1207    * specified.
1208    * @param pObject     pointer to TObject
1209    * @return data specification, kAliHLTVoidDataSpec if failed
1210    */
1211   AliHLTUInt32_t GetSpecification(const TObject* pObject=NULL);
1212
1213   /**
1214    * Get the first block of a specific data type from the input data.
1215    * The method looks for the first block of type dt in the input stream.
1216    * It is intended to be used within the high-level interface.<br>
1217    * \em Note: THE BLOCK DESCRIPTOR MUST NOT BE DELETED by the caller.
1218    *
1219    * If called without parameters, the function works on all input blocks,
1220    * also the ones of data type kAliHLTVoidDataType which are not matched by
1221    * kAliHLTAnyDataType.
1222    *
1223    * @param dt          data type of the block
1224    * @return pointer to @ref AliHLTComponentBlockData
1225    */
1226   const AliHLTComponentBlockData* GetFirstInputBlock(const AliHLTComponentDataType& dt=kAliHLTAllDataTypes);
1227
1228   /**
1229    * Get the first block of a specific data type from the input data.
1230    * The method looks for the first block of type specified by the ID and 
1231    * Origin strings in the input stream.  It is intended
1232    * to be used within the high-level interface.<br>
1233    * \em Note: THE BLOCK DESCRIPTOR MUST NOT BE DELETED by the caller.
1234    * @param dtID        data type ID of the block
1235    * @param dtOrigin    data type origin of the block
1236    * @return pointer to @ref AliHLTComponentBlockData
1237    */
1238   const AliHLTComponentBlockData* GetFirstInputBlock(const char* dtID, 
1239                                                       const char* dtOrigin);
1240
1241   /**
1242    * Get input block by index.<br>
1243    * \em Note: THE BLOCK DESCRIPTOR MUST NOT BE DELETED by the caller.
1244    * @return pointer to AliHLTComponentBlockData, NULL if index out of range
1245    */
1246   const AliHLTComponentBlockData* GetInputBlock(int index) const;
1247
1248   /**
1249    * Get the next block of a specific data type from the input data.
1250    * The method looks for the next block  of type and class specified
1251    * to the previous @ref GetFirstInputBlock call.
1252    * To be used within the high-level interface.<br>
1253    * \em Note: THE BLOCK DESCRIPTOR MUST NOT BE DELETED by the caller.
1254    */
1255   const AliHLTComponentBlockData* GetNextInputBlock();
1256
1257   /**
1258    * Get data specification of an input block.
1259    * Get data specification of the input block previously fetched via
1260    * GetFirstInputObject/NextInputObject or the last one if no block
1261    * specified.
1262    * @param pBlock     pointer to input block
1263    * @return data specification, kAliHLTVoidDataSpec if failed
1264    */
1265   AliHLTUInt32_t GetSpecification(const AliHLTComponentBlockData* pBlock);
1266
1267   /**
1268    * Forward an input object to the output.
1269    * Forward the input block of an object previously fetched via
1270    * GetFirstInputObject/NextInputObject or the last one if no object
1271    * specified.
1272    * The block descriptor of the input block is forwarded to the
1273    * output block list.
1274    * @param pObject     pointer to TObject
1275    * @return neg. error code if failed
1276    */
1277   int Forward(const TObject* pObject);
1278
1279   /**
1280    * Forward an input block to the output.
1281    * Forward the input block fetched via GetFirstInputObject/
1282    * NextInputBlock or the last one if no block specified.
1283    * The block descriptor of the input block is forwarded to the
1284    * output block list.
1285    * @param pBlock     pointer to input block
1286    * @return neg. error code if failed
1287    */
1288   int Forward(const AliHLTComponentBlockData* pBlock=NULL);
1289
1290   /**
1291    * Insert an object into the output.
1292    * If header is specified, it will be inserted before the root object,
1293    * default is no header.
1294    * The publishing can be downscaled by means of the -pushback-period
1295    * parameter. This is especially useful for histograms which do not
1296    * need to be sent for every event.
1297    * @param pObject     pointer to root object
1298    * @param dt          data type of the object
1299    * @param spec        data specification
1300    * @param pHeader     pointer to header
1301    * @param headerSize  size of Header
1302    * @return neg. error code if failed 
1303    */
1304   int PushBack(TObject* pObject, const AliHLTComponentDataType& dt, 
1305                AliHLTUInt32_t spec=kAliHLTVoidDataSpec, 
1306                void* pHeader=NULL, int headerSize=0);
1307
1308   /**
1309    * Insert an object into the output.
1310    * If header is specified, it will be inserted before the root object,
1311    * default is no header.
1312    * The publishing can be downscaled by means of the -pushback-period
1313    * parameter. This is especially useful for histograms which do not
1314    * need to be sent for every event.
1315    * @param pObject     pointer to root object
1316    * @param dtID        data type ID of the object
1317    * @param dtOrigin    data type origin of the object
1318    * @param spec        data specification
1319    * @param pHeader     pointer to header
1320    * @param headerSize  size of Header
1321    * @return neg. error code if failed 
1322    */
1323   int PushBack(TObject* pObject, const char* dtID, const char* dtOrigin,
1324                AliHLTUInt32_t spec=kAliHLTVoidDataSpec,
1325                void* pHeader=NULL, int headerSize=0);
1326  
1327   /**
1328    * Insert an object into the output.
1329    * @param pBuffer     pointer to buffer
1330    * @param iSize       size of the buffer
1331    * @param dt          data type of the object
1332    * @param spec        data specification
1333    * @param pHeader     pointer to header
1334    * @param headerSize size of Header
1335    * @return neg. error code if failed 
1336    */
1337   int PushBack(const void* pBuffer, int iSize, const AliHLTComponentDataType& dt,
1338                AliHLTUInt32_t spec=kAliHLTVoidDataSpec,
1339                const void* pHeader=NULL, int headerSize=0);
1340
1341   /**
1342    * Insert an object into the output.
1343    * @param pBuffer     pointer to buffer
1344    * @param iSize       size of the buffer
1345    * @param dtID        data type ID of the object
1346    * @param dtOrigin    data type origin of the object
1347    * @param spec        data specification
1348    * @param pHeader     pointer to header
1349    * @param headerSize size of Header
1350    * @return neg. error code if failed 
1351    */
1352   int PushBack(const void* pBuffer, int iSize, const char* dtID, const char* dtOrigin,
1353                AliHLTUInt32_t spec=kAliHLTVoidDataSpec,
1354                const void* pHeader=NULL, int headerSize=0);
1355
1356   /**
1357    * Estimate size of a TObject
1358    * @param pObject
1359    * @return buffer size in byte
1360    */
1361   int EstimateObjectSize(TObject* pObject) const;
1362
1363   /**
1364    * Create a memory file in the output stream.
1365    * This method creates a TFile object which stores all data in
1366    * memory instead of disk. The TFile object is published as binary data.
1367    * The instance can be used like a normal TFile object. The TFile::Close
1368    * or @ref CloseMemoryFile method has to be called in order to flush the
1369    * output stream.
1370    *
1371    * \b Note: The returned object is deleted by the framework.
1372    * @param capacity    total size reserved for the memory file
1373    * @param dtID        data type ID of the file
1374    * @param dtOrigin    data type origin of the file
1375    * @param spec        data specification
1376    * @return file handle, NULL if failed 
1377    */
1378   AliHLTMemoryFile* CreateMemoryFile(int capacity, const char* dtID, const char* dtOrigin,
1379                                      AliHLTUInt32_t spec=kAliHLTVoidDataSpec);
1380
1381   /**
1382    * Create a memory file in the output stream.
1383    * This method creates a TFile object which stores all data in
1384    * memory instead of disk. The TFile object is published as binary data.
1385    * The instance can be used like a normal TFile object. The TFile::Close
1386    * or @ref CloseMemoryFile method has to be called in order to flush the
1387    * output stream.
1388    *
1389    * \b Note: The returned object is deleted by the framework.
1390    * @param capacity    total size reserved for the memory file
1391    * @param dt          data type of the file
1392    * @param spec        data specification
1393    * @return file handle, NULL if failed 
1394    */
1395   AliHLTMemoryFile* CreateMemoryFile(int capacity, 
1396                                      const AliHLTComponentDataType& dt=kAliHLTAnyDataType,
1397                                      AliHLTUInt32_t spec=kAliHLTVoidDataSpec);
1398
1399   /**
1400    * Create a memory file in the output stream.
1401    * This method creates a TFile object which stores all data in
1402    * memory instead of disk. The TFile object is published as binary data.
1403    * The instance can be used like a normal TFile object. The TFile::Close
1404    * or @ref CloseMemoryFile method has to be called in order to flush the
1405    * output stream.
1406    *
1407    * \b Note: The returned object is deleted by the framework.
1408    * @param dtID        data type ID of the file
1409    * @param dtOrigin    data type origin of the file
1410    * @param spec        data specification
1411    * @param capacity    fraction of the available output buffer size
1412    * @return file handle, NULL if failed 
1413    */
1414   AliHLTMemoryFile* CreateMemoryFile(const char* dtID, const char* dtOrigin,
1415                                      AliHLTUInt32_t spec=kAliHLTVoidDataSpec,
1416                                      float capacity=1.0);
1417
1418   /**
1419    * Create a memory file in the output stream.
1420    * This method creates a TFile object which stores all data in
1421    * memory instead of disk. The TFile object is published as binary data.
1422    * The instance can be used like a normal TFile object. The TFile::Close
1423    * or @ref CloseMemoryFile method has to be called in order to flush the
1424    * output stream.
1425    *
1426    * \b Note: The returned object is deleted by the framework.
1427    * @param dt          data type of the file
1428    * @param spec        data specification
1429    * @param capacity    fraction of the available output buffer size
1430    * @return file handle, NULL if failed 
1431    */
1432   AliHLTMemoryFile* CreateMemoryFile(const AliHLTComponentDataType& dt=kAliHLTAnyDataType,
1433                                      AliHLTUInt32_t spec=kAliHLTVoidDataSpec,
1434                                      float capacity=1.0);
1435
1436   /**
1437    * Write an object to memory file in the output stream.
1438    * @param pFile       file handle
1439    * @param pObject     pointer to root object
1440    * @param key         key in ROOT file
1441    * @param option      options, see TObject::Write
1442    * @return neg. error code if failed
1443    *         - -ENOSPC    no space left
1444    */
1445   int Write(AliHLTMemoryFile* pFile, const TObject* pObject, const char* key=NULL, int option=TObject::kOverwrite);
1446
1447   /**
1448    * Close object memory file.
1449    * @param pFile       file handle
1450    * @return neg. error code if failed
1451    *         - -ENOSPC    buffer size too small
1452    */
1453   int CloseMemoryFile(AliHLTMemoryFile* pFile);
1454
1455   /**
1456    * Insert event-done data information into the output.
1457    * @param edd          event-done data information
1458    */
1459   int CreateEventDoneData(AliHLTComponentEventDoneData edd);
1460
1461   /**
1462    * Get current run number
1463    */
1464   AliHLTUInt32_t GetRunNo() const;
1465
1466   /**
1467    * Get the current run type.
1468    */
1469   AliHLTUInt32_t GetRunType() const;
1470
1471   /**
1472    * Get the chain id of the component.
1473    */
1474   const char* GetChainId() const {return fChainId.c_str();}
1475
1476   /**
1477    * Get a timestamp of the current event
1478    * Exact format needs to be documented.
1479    */
1480   AliHLTUInt32_t    GetTimeStamp() const;
1481
1482   /**
1483    * Get the period number.
1484    * Upper 28 bits (36 to 63) of the 64-bit event id 
1485    */
1486   AliHLTUInt32_t    GetPeriodNumber() const;
1487
1488   /**
1489    * Get the period number.
1490    * 24 bits, 12 to 35 of the 64-bit event id 
1491    */
1492   AliHLTUInt32_t    GetOrbitNumber() const;
1493
1494   /**
1495    * Get the bunch crossing number.
1496    * 12 bits, 0 to 12 of the 64-bit event id 
1497    */
1498   AliHLTUInt16_t    GetBunchCrossNumber() const;
1499
1500   /**
1501    * Setup the CTP accounting functionality of the base class.
1502    * The method can be invoked from DoInit() for componenets which want to
1503    * use the CTP functionality of the base class.
1504    *
1505    * The AliHLTCTPData is initialized with the trigger classes from the ECS
1506    * parameters. The base class automatically increments the counters according
1507    * to the trigger pattern in the CDH before the event processing. 
1508    */
1509   int SetupCTPData();
1510
1511   /**
1512    * Get the instance of the CTP data.
1513    */
1514   const AliHLTCTPData* CTPData() const {return fpCTPData;}
1515
1516   /**
1517    * Check whether a combination of trigger classes is fired.
1518    * The expression can contain trigger class ids and logic operators
1519    * like &&, ||, !, and ^, and may be grouped by parentheses.
1520    * @note the function requires the setup of the CTP handling for the component by
1521    * invoking SetupCTPData() from DoInit()
1522    * @param expression     a logic expression of trigger class ids
1523    * @param trigData       the trigger data data
1524    */
1525   bool EvaluateCTPTriggerClass(const char* expression, AliHLTComponentTriggerData& trigData) const;
1526
1527   /**
1528    * Check state of a trigger class.
1529    * If the class name is not part of the current trigger setup (i.e. ECS parameter
1530    * does not contain a trigger definition for this class name) the function
1531    * returns -1
1532    * @note the function requires the setup of the CTP handling for the component by
1533    * invoking SetupCTPData() from DoInit()
1534    * @return -1 class name not initialized, 
1535    *          0 trigger not active
1536    *          1 trigger active
1537    */
1538   int CheckCTPTrigger(const char* name) const;
1539
1540   /**
1541    * Get the overall solenoid field.
1542    */
1543   Double_t GetBz();
1544   /**
1545    * Get the solenoid field at point r.
1546    */
1547   Double_t GetBz(const Double_t *r);
1548   /**
1549    * Get the solenoid field components at point r.
1550    */
1551   void GetBxByBz(const Double_t r[3], Double_t b[3]);
1552
1553   /**
1554    * Check whether the current event is a valid data event.
1555    * @param pTgt    optional pointer to get the event type
1556    * @return true if the current event is a real data event
1557    */
1558   bool IsDataEvent(AliHLTUInt32_t* pTgt=NULL) const;
1559
1560   /**
1561    * Copy a struct from block data.
1562    * The function checks for block size and struct size. The least common
1563    * size will be copied to the target struct, remaining fields are initialized
1564    * to zero.<br>
1565    * The target struct must have a 32bit struct size indicator as first member.
1566    * @param pStruct     target struct
1567    * @param iStructSize size of the struct
1568    * @param iBlockNo    index of input block
1569    * @param structname  name of the struct (log messages)
1570    * @param eventname   name of the event (log messages)
1571    * @return size copied, neg. error if failed
1572    */
1573   int CopyStruct(void* pStruct, unsigned int iStructSize, unsigned int iBlockNo,
1574                  const char* structname="", const char* eventname="");
1575
1576  private:
1577   /** copy constructor prohibited */
1578   AliHLTComponent(const AliHLTComponent&);
1579   /** assignment operator prohibited */
1580   AliHLTComponent& operator=(const AliHLTComponent&);
1581
1582   /**
1583    * Increment the internal event counter.
1584    * To be used by the friend classes AliHLTProcessor, AliHLTDataSource
1585    * and AliHLTDataSink.
1586    * @return new value of the internal event counter
1587    * @internal
1588    */
1589   int IncrementEventCounter();
1590
1591   /**
1592    * Find the first input block of specified data type beginning at index.
1593    * Input blocks containing a TObject have the size of the object as an
1594    * unsigned 32 bit number in the first 4 bytes. This has to match the block
1595    * size minus 4.
1596    *
1597    * kAliHLTAllDataTypes is a special data type which includes both 
1598    * kAliHLTVoidDataType and kAliHLTAnyDataType.
1599    *
1600    * @param dt          data type
1601    * @param startIdx    index to start the search
1602    * @param bObject     check if this is an object
1603    * @return index of the block, -ENOENT if no block found
1604    *
1605    * @internal
1606    */
1607   int FindInputBlock(const AliHLTComponentDataType& dt, int startIdx=-1, int bObject=0) const;
1608
1609   /**
1610    * Get index in the array of input bocks.
1611    * Calculate index and check integrety of a block data structure pointer.
1612    * @param pBlock      pointer to block data
1613    * @return index of the block, -ENOENT if no block found
1614    *
1615    * @internal
1616    */
1617   int FindInputBlock(const AliHLTComponentBlockData* pBlock) const;
1618
1619   /**
1620    * Create an object from a specified input block.
1621    * @param idx         index of the input block
1622    * @param bForce      force the retrieval of an object, error messages
1623    *                    are suppressed if \em bForce is not set
1624    * @return pointer to TObject, caller must delete the object after use
1625    *
1626    * @internal
1627    */
1628   TObject* CreateInputObject(int idx, int bForce=0);
1629
1630   /**
1631    * Get input object
1632    * Get object from the input block list. The methods first checks whether the
1633    * object was already created. If not, it is created by @ref CreateInputObject
1634    * and inserted into the list of objects.
1635    * @param idx         index in the input block list
1636    * @param classname   name of the class, object is checked for correct class
1637    *                    name if set
1638    * @param bForce      force the retrieval of an object, error messages
1639    *                    are suppressed if \em bForce is not set
1640    * @return pointer to TObject
1641    *
1642    * @internal
1643    */
1644   TObject* GetInputObject(int idx, const char* classname=NULL, int bForce=0);
1645
1646   /**
1647    * Clean the list of input objects.
1648    * Cleanup is done at the end of each event processing.
1649    */
1650   int CleanupInputObjects();
1651
1652   /**
1653    * Insert a buffer into the output block stream.
1654    * This is the only method to insert blocks into the output stream, called
1655    * from all types of the Pushback method. The actual data might have been
1656    * written to the output buffer already. In that case NULL can be provided
1657    * as buffer, only the block descriptor will be build. If a header is specified, 
1658    * it will be inserted before the buffer, default is no header.
1659    * @param pBuffer     pointer to buffer
1660    * @param iBufferSize size of the buffer in byte
1661    * @param dt          data type
1662    * @param spec        data specification
1663    * @param pHeader     pointer to header
1664    * @param iHeaderSize size of Header
1665    * @return neg. error code if failed
1666    */
1667   int InsertOutputBlock(const void* pBuffer, int iBufferSize,
1668                         const AliHLTComponentDataType& dt,
1669                         AliHLTUInt32_t spec,
1670                         const void* pHeader=NULL, int iHeaderSize=0);
1671
1672   /**
1673    * Add a component statistics block to the output.
1674    * @return size of the added data
1675    */
1676   int AddComponentStatistics(AliHLTComponentBlockDataList& blocks, 
1677                              AliHLTUInt8_t* buffer,
1678                              AliHLTUInt32_t bufferSize,
1679                              AliHLTUInt32_t offset,
1680                              AliHLTComponentStatisticsList& stats) const;
1681
1682   /**
1683    * Add a component table entry (descriptor) to the output
1684    * This is done at SOR/EOR. The component table is a list of chain ids
1685    * and 32bit ids calculated by a crc algorithm from the chian id. This
1686    * allows to tag data blocks with the id number rather than the string.
1687    *
1688    * The kAliHLTDataTypeComponentTable data block currently has the string
1689    * as payload and the crc id as specification.
1690    * @return size of the added data
1691    */
1692   int  AddComponentTableEntry(AliHLTComponentBlockDataList& blocks, 
1693                               AliHLTUInt8_t* buffer,
1694                               AliHLTUInt32_t bufferSize,
1695                               AliHLTUInt32_t offset,
1696                               const vector<AliHLTUInt32_t>& parents) const;
1697
1698   /**
1699    * Scan the ECS parameter string.
1700    * The framework provides both the parameters of CONFIGURE and ENGAGE
1701    * in one string in a special data block kAliHLTDataTypeECSParam
1702    * {ECSPARAM:PRIV}. The general format is
1703    * <command>;<parameterkey>=<parametervalue>;<parameterkey>=<parametervalue>;...
1704    */
1705   int ScanECSParam(const char* ecsParam);
1706
1707   /**
1708    * The trigger classes are determined from the trigger and propagated by
1709    * ECS as part of the ENGAGE command parameter which is sent through the
1710    * framework during the SOR event. This function treats the value of the
1711    * parameter key CTP_TRIGGER_CLASS.
1712    */
1713   int InitCTPTriggerClasses(const char* ctpString);
1714
1715   enum {
1716     kRequireSteeringBlocks = 0x1,
1717     kDisableComponentStat = 0x2
1718   };
1719
1720   /** The global component handler instance */
1721   static AliHLTComponentHandler* fgpComponentHandler;              //! transient
1722
1723   /** The environment where the component is running in */
1724   AliHLTAnalysisEnvironment fEnvironment;                         // see above
1725
1726   /** Set by ProcessEvent before the processing starts */
1727   AliHLTEventID_t fCurrentEvent;                                   // see above
1728
1729   /** internal event no */
1730   int fEventCount;                                                 // see above
1731
1732   /** the number of failed events */
1733   int fFailedEvents;                                               // see above
1734
1735   /** event data struct of the current event under processing */
1736   AliHLTComponentEventData fCurrentEventData;                      // see above
1737
1738   /** array of input data blocks of the current event */
1739   const AliHLTComponentBlockData* fpInputBlocks;                   //! transient
1740
1741   /** index of the current input block */
1742   int fCurrentInputBlock;                                          // see above
1743
1744   /** data type of the last block search */
1745   AliHLTComponentDataType fSearchDataType;                         // see above
1746
1747   /** name of the class for the object to search for */
1748   string fClassName;                                               // see above
1749
1750   /** array of generated input objects */
1751   TObjArray* fpInputObjects;                                       //! transient
1752  
1753   /** the output buffer */
1754   AliHLTUInt8_t* fpOutputBuffer;                                   //! transient
1755
1756   /** size of the output buffer */
1757   AliHLTUInt32_t fOutputBufferSize;                                // see above
1758
1759   /** size of data written to output buffer */
1760   AliHLTUInt32_t fOutputBufferFilled;                              // see above
1761
1762   /** list of ouput block data descriptors */
1763   AliHLTComponentBlockDataList fOutputBlocks;                      // see above
1764
1765   /** stopwatch array */
1766   TObjArray* fpStopwatches;                                        //! transient
1767
1768   /** array of memory files AliHLTMemoryFile */
1769   AliHLTMemoryFilePList fMemFiles;                                 //! transient
1770
1771   /** descriptor of the current run */
1772   AliHLTRunDesc* fpRunDesc;                                        //! transient
1773
1774   /** external fct to set CDB run no, indicates external CDB initialization */
1775   void (*fCDBSetRunNoFunc)();                                      //! transient
1776
1777   /** id of the component in the analysis chain */
1778   string fChainId;                                                 //! transient
1779
1780   /** crc value of the chainid, used as a 32bit id */
1781   AliHLTUInt32_t fChainIdCrc;                                      //! transient
1782
1783   /** optional benchmarking for the component statistics */
1784   TStopwatch* fpBenchmark;                                         //! transient
1785
1786   /** component flags, cleared in Deinit */
1787   AliHLTUInt32_t fFlags;                                           //! transient
1788
1789   /** current event type */
1790   AliHLTUInt32_t fEventType;                                       //! transient
1791
1792   /** component arguments */
1793   string fComponentArgs;                                           //! transient
1794
1795
1796   /** event done data */
1797   AliHLTComponentEventDoneData* fEventDoneData;                    //! transient
1798
1799   /** Reserved size of the memory stored at fEventDoneData */
1800   unsigned long fEventDoneDataSize;                                //! transient
1801
1802   /** Comression level for ROOT objects */
1803   int fCompressionLevel;                                           //! transient
1804
1805   /** size of last PushBack-serialized object */
1806   int fLastObjectSize;                                             //! transient
1807
1808  /**  array of trigger class descriptors */
1809   AliHLTCTPData* fpCTPData;                                        //! transient
1810
1811   /// update period for PushBack calls
1812   int fPushbackPeriod;                                             //! transient
1813   /// time of last executed PushBack
1814   int fLastPushBackTime;                                           //! transient
1815
1816   ClassDef(AliHLTComponent, 0)
1817 };
1818 #endif