8ee934ebd8e7490cd11ecd3c726238839684fa16
[u/mrichter/AliRoot.git] / HLT / BASE / AliHLTSystem.h
1 //-*- Mode: C++ -*-
2 // $Id$
3
4 #ifndef ALIHLTSYSTEM_H
5 #define ALIHLTSYSTEM_H
6 //* This file is property of and copyright by the                          * 
7 //* ALICE Experiment at CERN, All rights reserved.                         *
8 //* See cxx source for full Copyright notice                               *
9
10 //  @file   AliHLTSystem.h
11 //  @author Matthias Richter
12 //  @date   2007
13 //  @brief  Global HLT module management and AliRoot integration.
14 //  @note   The class is used in Offline (AliRoot) context
15 // 
16
17 /**
18  * @defgroup alihlt_system HLT integration into AliRoot
19  * This section describes the HLT integration into AliRoot.
20  * 
21  * @section alihlt_system_intro General Remarks
22  * The HLT analysis is organized in components which can also be used 
23  * in off-line processing. Two different types of off-line applications 
24  * can be distinguished:
25  * - AliRoot simulation (AliSimulation)
26  * - AliRoot reconstruction (AliReconstruction)
27  *
28  * In either case an HLT chain described by means of AliHLTConfiguration
29  * builds the core of any HLT application. Special components exist, which 
30  * emulate the behavior of the components of the HLT on-line data 
31  * transportation framework. Together with the analysis components, this 
32  * allows the full emulation of the behavoir of HLT analysis chain off-line.
33  *
34  * More details how to setup up such a chain can be found:
35  * - The examples page under @ref tut_hltsystem
36  *
37  * @section alihlt_system_simulation AliRoot simulation
38  * HLT has a special role in the normal data flow  of simulation and
39  * reconstruction. Since the HLT reconstruction and analysis runs on-line
40  * on the HLT farm, the raw data produced by HLT as a detector contains
41  * already reconstructed events. Consequently, the HLT response has to be
42  * simulated as well as the data of all other detectors. 
43  *
44  * Since the detector data is needed, the HLT simulation is run at the 
45  * end of AliSimulation.
46  *
47  * As a matter of fact, HLT always reconstructs data, <em><b>HLT simulation
48  * </b></em> means <em><b>HLT reconstruction embedded into AliRoot</b></em>.
49  *
50  * More Details an be found in the module: 
51  * - @ref alihlt_aliroot_simulation
52  *
53  * @section alihlt_system_reconstruction AliRoot reconstruction
54  *
55  * Like all other ALICE detectors, HLT utilizes the AliReconstruction interface
56  * to implement a plugin for the AliRoot reconstruction. The reconstructor can be
57  * used to
58  * - run HLT analysis chains in the AliRoot reconstruction <br>
59  *   This option is mainly intended for the development and debugging cycle. HLT
60  *   chains can be defined by means of AliHLTConfiguration and can be run either
61  *   stand-alone or embedded into the AliReconstruction cycle.
62  * - run the default analysis chains <br>
63  *   HLT modules can define default analysis chains to be run during AliRoot
64  *   reconstruction.
65  * - handle the HLTOUT data<br>
66  *   The HLT output stream contains multiple data blocks produced by the various
67  *   components of the HLT chain. Each block might need different and even
68  *   detector specific processing, like e.g. the processing of ESD objects or the
69  *   handling of compressed data.
70  *
71  * More Details an be found in the module: 
72  * - @ref alihlt_aliroot_reconstruction
73  *
74  */
75
76 #include "AliHLTLogging.h"
77 #include <TList.h>
78 #include <TString.h>
79
80 class AliHLTComponentHandler;
81 class AliHLTConfiguration;
82 class AliHLTConfigurationHandler;
83 class AliHLTTask;
84 class AliHLTOUT;
85 class AliHLTOUTTask;
86 class AliHLTControlTask;
87 class AliRunLoader;
88 class AliRawReader;
89 class AliESDEvent;
90 class TObjArray;
91 class TStopwatch;
92
93 /**
94  * @class AliHLTSystem
95  * Main class for the HLT integration into AliRoot.
96  * @note This class is only used for the @ref alihlt_system.
97  *
98  * @section alihltsystem_overview Main functionality
99  * The class implements the main binding functionality to run HLT
100  * embedded in AliRoot:
101  * - creates handlers for HLT components (AliHLTComponentHandler)
102  * and configurations (AliHLTConfigurationHandler).
103  * - implements the creation of a task list from configurations
104  * - runs the tasks of the task list
105  * - implements the interface to AliHLTReconstructor and AliHLTSimulation
106  * - manages the registered module agents (AliHLTModuleAgent) 
107  *
108  * @section alihltsystem_functions Main functions
109  * The following list gives the most important functions, see documentation
110  * of functions for details.
111  * - ScanOptions(const char*) initialize the system from arguments
112  * - BuildTaskList(const char*) build task list for a reconstruction chain
113  * - Run() processing loop for task list
114  * - Reconstruct() interface to AliHLTReconstructor
115  * - ProcessHLTOUT() process an HLTOUT colection
116  *
117  * @section alihltsystem_initialization Initialization
118  * AliHLTSystem is initialized with a list of component libraries which determine
119  * the actual functionality. See ScanOptions() for description of options.
120  *
121  * @section alihltsystem_usage Usage
122  * The class AliHLTPluginBase handles the global instance of AliHLTSystem,
123  * the instance is created and fetched like 
124  * <pre>
125  * // setup the HLT system
126  * AliHLTSystem* pHLT=AliHLTPluginBase::GetInstance();
127  * </pre>
128  *
129  * @ingroup alihlt_system
130  */
131 class AliHLTSystem : public AliHLTLogging {
132  public:
133   /** default constructor */
134   AliHLTSystem(AliHLTComponentLogSeverity loglevel=kHLTLogDefault,
135                const char* name="",
136                AliHLTComponentHandler* pCompHandler=NULL,
137                AliHLTConfigurationHandler* pConfHandler=NULL
138                );
139   /** destructor */
140   virtual ~AliHLTSystem();
141
142   /**
143    * Build a task list 
144    * This method is used to build the list of tasks from the configuration
145    * id of a single 'master' configuration.
146    *
147    * Configuration entries might depend upon other configurations. For each
148    * configuration which has not yet been converted into an AliHLTTask, the
149    * method will be called iteratively. Finally, after building all tasks
150    * providing the input for the current one, the task is inserted to the
151    * list of tasks with the InsertTask() method.
152    *
153    * The function can be called multiple times in order to add more than one
154    * chain to the system.
155    *
156    * @param pConf    configuration name/id
157    */
158   int BuildTaskList(const char* pConf);
159
160   /**
161    * Clean the list of tasks and delete all the task objects.
162    */
163   int CleanTaskList();
164
165   /**
166    * Insert a task to the task list.
167    * The method first checks whether all dependencies are resolved (i.e. exist 
168    * already in the task list). During this iteration the cross links between
169    * the tasks are set as well. If all dependencies are resolved, the task is
170    * added at the end of the list.
171    * @param pTask    pointer to task to add
172    */
173   int InsertTask(AliHLTTask* pTask);
174
175   /**
176    * Add HLTOUT task to the end of the task list.
177    * If one of the specified chains has output, an AliHLTOUTTask is
178    * added which controls the output. All other chains are removed from the
179    * AliHLTOUTTask input.
180    * @return 0 if no task has been added, 1 if task has been added
181    */
182   int AddHLTOUTTask(const char* chains);
183
184   AliHLTOUTTask* GetHLTOUTTask() const {return fpHLTOUTTask;}
185   AliHLTComponentHandler* GetComponentHandler() const {return fpComponentHandler;}
186   AliHLTConfigurationHandler* GetConfigurationHandler() const {return fpConfigurationHandler;}
187
188   /**
189    * Find a task with an id.
190    * @param id       CONFIGURATION id (not a COMPONENT id!)
191    */
192   AliHLTTask* FindTask(const char* id);
193
194   /**
195    * Print the task list.
196    */
197   void PrintTaskList();
198
199   /**
200    * Run one or more events.
201    * Core of the processing loop. The method expects the task list to be
202    * already created by a previous call to BuildTaskList(const char*)
203    *
204    * All tasks of the list will be subsequently processed for each event.
205    * The system can remain started if the \em bStop parameter is 0. In that
206    * case the system just waits for the next event. A specific call with
207    * nofEvents==0 is needed to execute the stop sequence.
208    * @param iNofEvents number of events
209    * @param bStop      stop the chain after processing
210    * @param trgMask    ctp trigger mask from the rawreader
211    * @param timestamp  timestamp of the event, read from the rawreader
212    * @param eventtype  event type, read from the rawreader
213    * @param participatingDetectors  the bit flags of the participating detectors
214    *           as will we inserted into the Common Data Header. This should only
215    *           be used for software event types.
216    * @return number of reconstructed events, neg error code if failed
217    */
218   int Run(Int_t iNofEvents, int bStop, AliHLTUInt64_t trgMask,
219           AliHLTUInt32_t timestamp, AliHLTUInt32_t eventtype,
220           AliHLTUInt32_t participatingDetectors = 0);
221
222   /**
223    * Run the tasklist
224    * Somehow the 64bit variable/default value did not work out on mac.
225    * Re-introducing the original function, and forwarding it.
226    */
227   int Run(Int_t iNofEvents=1, int bStop=1)
228   {return Run(iNofEvents, bStop, 0, 0, 0);}
229
230   /**
231    * Init all tasks from the list.
232    * The @ref AliHLTTask::Init method is called for each task, the components
233    * will be created.
234    * @return neg error code if failed
235    */
236   int InitTasks();
237
238   /**
239    * Init the stopwatches for all tasks.
240    * @param pStopwatches    object array of stopwatches, for types
241    *                        @see AliHLTComponent::AliHLTStopwatchType
242    * @return neg error code if failed
243    */
244   int InitBenchmarking(TObjArray* pStopwatches);
245
246   /**
247    * Stop the stopwatches for all tasks.
248    * @param pStopwatches    object array of stopwatches, for types
249    *                        @see AliHLTComponent::AliHLTStopwatchType
250    * @return neg error code if failed
251    */
252   int PauseBenchmarking(TObjArray* pStopwatches) const;
253
254   /**
255    * Continue the stopwatches for all tasks.
256    * @param pStopwatches    object array of stopwatches, for types
257    *                        @see AliHLTComponent::AliHLTStopwatchType
258    * @return neg error code if failed
259    */
260   int ResumeBenchmarking(TObjArray* pStopwatches) const;
261
262   /**
263    * Print benchmarking summary.
264    * Optionak: clean up stop watches.
265    * @param pStopwatches    object array of stopwatches
266    * @param bClean          delete stop watches if 1
267    * @return neg error code if failed
268    */
269   int PrintBenchmarking(TObjArray* pStopwatches, int bClean=0) const;
270
271   /**
272    * Start task list.
273    * The @ref AliHLTTask::StartRun method is called for each task, the
274    * components will be prepared for event processing.
275    * @return neg error code if failed
276    */
277   int StartTasks();
278
279   /**
280    * Process task list.
281    * The @ref AliHLTTask::ProcessTask method is called for each task.
282    * @return neg error code if failed
283    */
284   int ProcessTasks(Int_t eventNo, AliHLTUInt64_t trgMask,
285                    AliHLTUInt32_t timestamp, AliHLTUInt32_t eventtype,
286                    AliHLTUInt32_t participatingDetectors = 0);
287
288   /**
289    * Stop task list.
290    * The @ref AliHLTTask::EndRun method is called for each task, the components
291    * will be cleaned after event processing.
292    * @return neg error code if failed
293    */
294   int StopTasks();
295
296   /**
297    * Send a control event trough the chain.
298    * All data sources in the chain are switched to publish a control event like
299    * SOR or EOR. The event is propagated in the same way as a normal event.
300    * @param dt       type of the event
301    */
302   int SendControlEvent(AliHLTComponentDataType dt);
303
304   /**
305    * De-init all tasks from the list.
306    * The @ref AliHLTTask::Deinit method is called for each task, the components
307    * will be deleted.
308    * @return neg error code if failed
309    */
310   int DeinitTasks();
311
312   /**
313    * Cleanup all internal objects from HLTOUT processing.
314    * Go through the list of HLTOUT handlers and release them.
315    */
316   int CleanupHLTOUTHandlers();
317
318   /**
319    * The memory allocation function for components.
320    * This function is part of the running environment of the components, 
321    * see AliHLTAnalysisEnvironment
322    */
323   static void* AllocMemory( void* param, unsigned long size );
324
325   /**
326    * The allocation function for component EventDoneData.
327    * This function is part of the running environment of the components,
328    * see AliHLTAnalysisEnvironment
329    */
330   static int AllocEventDoneData( void* param, AliHLTEventID_t eventID, unsigned long size, AliHLTComponentEventDoneData** edd );
331
332   /**
333    * AliRoot embedded reconstruction.
334    * Main entry point to execute the HLT reconstruction from AliRoot. Called
335    * either by the AliHLTReconstructor plugin during AliRoot reconstruction
336    * of raw data, or AliHLTSimulation during simulation of data.
337    *
338    * The two cases are distinguished by the availablility of the AliRunLoader
339    * and raw reader.
340    * - AliRoot simulation: AliRunLoader is available and is propagated to the
341    *   module agents (AliHLTModuleAgent) to generate the corresponding
342    *   configurations and chains, and to the AliHLTOfflineSource components.
343    *   raw reader might be available depending on whether raw data was
344    *   simulated or not.
345    * - AliRoot reconstruction: raw reader is available and is propagated to
346    *   the agents and AliHLTOfflineSource components. AliRunLoader is always
347    *   NULL.
348    *
349    * The system remains started after the processing and just waits for the
350    * next event. A specific call with nofEvents==0 is needed to execute the
351    * stop sequence.
352    *
353    * The 'runLoader' and 'rawReader' parameters are propagated to all active
354    * AliHLTOfflineDataSource's and the HLT chain is processed for the given
355    * number of events. If the rawReader is NULL, reconstruction is done on
356    * simulated data, from real data if a RawReader is specified.
357    *
358    * After setting up the system with the reconstruction parameters the
359    * Run() method is called and carries out the processing of the chain.
360    *
361    * @param nofEvents     number of events
362    * @param runLoader     the AliRoot RunLoader
363    * @param rawReader     the AliRoot RawReader
364    * @return number of reconstructed events, neg. error code if failed 
365    */
366   int Reconstruct(int nofEvents, AliRunLoader* runLoader, 
367                   AliRawReader* rawReader=NULL);
368
369   /**
370    * Fill ESD for one event.
371    * To be called by the AliHLTReconstructor plugin during the event loop
372    * and FillESD method of the AliRoot reconstruction.
373    *
374    * The method is most likely deprecated as the scheme has been slightly
375    * changed. The ESD is filled by the HLTOUT handlers implemented by the
376    * HLT modules rather than by components within the reconstruction chain.
377    * Still, HLT reconstruction chains can be run during the AliRoot
378    * reconstruction, data produced by such chains is automatically added
379    * to the HLTOUT stream in order to be equivalent to the online HLT.
380    * The HLTOUT is processed during AliReconstruction at the end of the
381    * HLT event processing, literally during the FillESD method of the AliRoot
382    * reconstruction interface. The HLT module must implement HLTOUT handlers
383    * and provide those through the module agent.
384    *
385    * @param eventNo       current event no (Note: this event number is just a
386    *                      processing counter and is not related to the nature/
387    *                      origin of the event
388    * @param runLoader     the AliRoot runloader
389    * @param esd           an AliESDEvent instance
390    * @return neg. error code if failed 
391    */
392   int FillESD(int eventNo, AliRunLoader* runLoader, AliESDEvent* esd);
393
394   /**
395    * Init the HLTOUT instance for the current event.
396    * The instance can be used by other classes to get hold on the data
397    * from HLTOUT.
398    * @param  instance     instance to be set as the active HLTOUT
399    * @return -EBUSY other active instance already existing
400    */
401   int InitHLTOUT(AliHLTOUT* instance);
402
403   /**
404    * Invalidate the HLTOUT instance.
405    * @param  instance     target variable for the instance
406    * @return -EBUSY if instance in use
407    */
408   int InvalidateHLTOUT(AliHLTOUT** instance=NULL);
409
410   /**
411    * Get the HLTOUT instance.
412    * User method for processing classes. To be released after use.
413    * @return pointer to HLTOUT instance
414    */
415   AliHLTOUT* RequestHLTOUT();
416
417   /**
418    * Release the HLTOUT instance after use.
419    * @param instance      pointer to instance to be released
420    * @return -ENOENT if instance does not match
421    */
422   int ReleaseHLTOUT(const AliHLTOUT* instance);
423
424   /**
425    * Process the HLTOUT data.
426    * The provided instance of AliHLTOUT provides the access to the data.
427    * AliHLTSystem queries all registered module agents (AliHLTModuleAgent)
428    * for the ability to treat a specific data block. As the last step the
429    * ESD object is filled. Please note that the provided ESD is the hltEsd
430    * in case of AliReconstructor (switched in AliReconstruction).
431    */
432   int ProcessHLTOUT(AliHLTOUT* pHLTOUT, AliESDEvent* esd);
433
434   /**
435    * Process all kChain-type data blocks of the HLTOUT data.
436    * Handlers of type AliHLTModuleAgent::kChain are executed as the first
437    * step of the processing. The function is invoked from ProcessHLTOUT(),
438    * eventual output of the chain is added to the HLTOUT collection.
439    */
440   int ProcessHLTOUTkChain(AliHLTOUT* pHLTOUT);
441
442   /**
443    * Load component libraries.
444    * @param libs          string of blank separated library names
445    * @return neg. error code if failed 
446    */
447   int LoadComponentLibraries(const char* libs);
448
449   /**
450    * Find a symbol in a dynamically loaded library.
451    * @param library      library
452    * @param symbol       the symbol to find
453    * @return void pointer to function
454    */
455   AliHLTfctVoid FindDynamicSymbol(const char* library, const char* symbol);
456
457   /**
458    * Prepare the HLT system for running.
459    * - module agents are requested to register configurations
460    * - task lists are built from the reconstruction chains of the modules
461    *
462    * @param rawReader    instance of the raw reader or NULL
463    * @param runloader    optional instance of the AliRunLoader
464    * @return neg. error code if failed <br>
465    *         -EBUSY      system is in kRunning state <br>
466    */
467   int Configure(AliRawReader* rawReader, AliRunLoader* runloader=NULL);
468
469   /**
470    * Old method kept for backward compatibilty.
471    *
472    * @param runloader    optional instance of the AliRunLoader
473    * @return neg. error code if failed <br>
474    *         -EBUSY      system is in kRunning state <br>
475    */
476   int Configure(AliRunLoader* runloader=NULL);
477
478   /**
479    * Scan options and load component libraries.
480    * The options consist of blank separated tokens. Libraries can be just
481    * specified by their name, and can be excluded by adding a '!'-mark in
482    * front. <br>
483    * Further options
484    * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting -->
485    * \li loglevel=<i>level</i> <br>
486    *     logging level for this processing
487    * \li frameworklog=<i>level</i> <br>
488    *     logging level for framework classes
489    * \li alilog=off
490    *     disable redirection of log messages to AliLog class
491    * \li config=<i>macro</i>
492    *     configuration macro
493    * \li chains=<i>configuration</i>
494    *     comma separated list of configurations to be run during local
495    *     reconstruction
496    * \li libmode=<i>static,dynamic(default)</i>
497    *     libraries are persistent if loaded in mode <i>static</i>, i.e. they
498    *     can't be unloaded
499    */
500   int ScanOptions(const char* options);
501
502   /**
503    * Reset the HLT system.
504    * Reset is not possible while the system is in running state.
505    * @param bForce       force the reset
506    * @return neg. error code if failed <br>
507    *         -EBUSY      system is in kRunning state <br>
508    */
509   int Reset(int bForce=0);
510
511   /**
512    * Load the configurations specified by the module agents.
513    * The runLoader is passed to the agent and allows configuration
514    * selection.
515    * - AliSimulation: runloader valid, raw reader might be valid
516    * - AliReconstruction: runloader always NULL, raw reader valid
517    *
518    * @param rawReader    instance of the raw reader or NULL
519    * @param runloader    optional instance of the AliRunLoader
520    * @return neg. error code if failed 
521    */
522   int LoadConfigurations(AliRawReader* rawReader, AliRunLoader* runloader=NULL);
523
524   /**
525    * Get the reconstruction chains from all agents and build the task lists.
526    * AliHLTModuleAgent implementations can define reconstruction chains
527    * depending on the availibility of AliRunLoader and AliRawReader parameters.
528    *
529    * @param rawReader    instance of the raw reader or NULL
530    * @param runloader    optional instance of the AliRunLoader
531    * @return neg. error code if failed 
532    */
533   int BuildTaskListsFromReconstructionChains(AliRawReader* rawReader, 
534                                              AliRunLoader* runloader=NULL);
535
536   enum AliHLTSystemState {
537     kUninitialized       = 0x0,
538     kLibrariesLoaded     = 0x1,
539     kConfigurationLoaded = 0x2,
540     kTaskListCreated     = 0x4,
541     kReady               = 0x7,
542     kStarted             = 0x8,
543     kRunning             = 0x10,
544     kError               = 0x1000
545   };
546
547   /**
548    * Check status of the system.
549    * @param flag          AliHLTSystemState value to check for
550    * @return 1 if set, 0 if not
551    */
552   int CheckStatus(int flag);
553
554   /**
555    * Get the current status.
556    * @return status flags of @ref AliHLTSystemState
557    */
558   int GetStatusFlags();
559
560   /**
561    * Set logging level for framework classes.
562    * This sets the local logging level of this instance and all subsequent
563    * framework classes to \em level.
564    * @param level     local logging level for the framework classes
565    */
566   void SetFrameworkLog(AliHLTComponentLogSeverity level);
567
568   /**
569    * Customized logging function.
570    * The name of the system and pointer is added at the beginning of each
571    * message if name was set.
572    */
573   int LoggingVarargs(AliHLTComponentLogSeverity severity, 
574                      const char* originClass, const char* originFunc,
575                      const char* file, int line, ... ) const;
576
577  protected:
578  
579  private:
580   /** copy constructor prohibited */
581   AliHLTSystem(const AliHLTSystem&);
582   /** assignment operator prohibited */
583   AliHLTSystem& operator=(const AliHLTSystem&);
584
585   /**
586    * Build task list from a configuration object. 
587    * This method implements the configuration parsing and transformation into
588    * a list of AliHLTTask objects. It has been made private in April 2007. 
589    * Use BuildTaskList(const char*) instead.
590    *
591    * @param pConf    pointer to configuration to build the task list from
592    */
593   int BuildTaskList(AliHLTConfiguration* pConf);
594
595   /**
596    * Set status flags.
597    */
598   int SetStatusFlags(int flags);
599
600   /**
601    * clear status flags.
602    */
603   int ClearStatusFlags(int flags);
604
605   /// Pointer to an instance of @ref AliHLTComponentHandler.
606   AliHLTComponentHandler* fpComponentHandler;                      //! transient
607
608   /// Pointer to an instance of @ref AliHLTConfigurationHandler.
609   AliHLTConfigurationHandler* fpConfigurationHandler;              //! transient
610
611   /** list of tasks */
612   TList fTaskList;                                                 // see above
613
614   /** the number of instances of AliHLTSystem */
615   static int fgNofInstances;                                       // see above
616
617   /** state of the object */
618   int fState;                                                      // see above
619
620   /** chains to be run during reconstruction */
621   TString fChains;                                                 //!transient
622
623   /** array of stopwatches */
624   TObjArray* fStopwatches;                                         //!transient
625
626   /** number of events processed in total */                        
627   int fEventCount;                                                 //!transient
628
629   /** number of events processed successfully */
630   int fGoodEvents;                                                 //!transient
631
632   /** array of default libraries */
633   static const char* fgkHLTDefaultLibs[];                          //!transient
634
635   /** active kChain handlers (AliHLTOUT::AliHLTOUTHandlerListEntryVector*) */
636   void* fpChainHandlers;                                           //!transient
637
638   /** active kEsd handlers (AliHLTOUT::AliHLTOUTHandlerListEntryVector*) */
639   void* fpEsdHandlers;                                             //!transient
640
641   /** active kProprietary handlers (AliHLTOUT::AliHLTOUTHandlerListEntryVector*) */
642   void* fpProprietaryHandlers;                                     //!transient
643
644   /** active HLTOUT task for the reconstruction */
645   AliHLTOUTTask* fpHLTOUTTask;                                     //!transient
646
647   /** HLTOUT instance for the current event */
648   AliHLTOUT* fpHLTOUT;                                            //!transient
649
650   /** HLTOUT use counter */
651   int fHLTOUTUse;                                                  //!transient
652
653   /** special task to publish the control events */
654   AliHLTControlTask* fpControlTask;                                //!transient
655
656   /** name of this system instance */
657   TString fName;                                                   //!transient
658
659   /// ECS parameter string
660   TString fECSParams;                                              //!transient
661
662   /// indicate the argument 'hltout-type'
663   bool fUseHLTOUTComponentTypeGlobal;                              //!transient
664
665   ClassDef(AliHLTSystem, 0);
666 };
667
668 #endif