//* ALICE Experiment at CERN, All rights reserved. *
//* See cxx source for full Copyright notice *
-/** @file AliHLTComponent.h
- @author Matthias Richter, Timm Steinbeck
- @date
- @brief Base class declaration for HLT components.
- @note The class is both used in Online (PubSub) and Offline (AliRoot)
- context
-*/
+// @file AliHLTComponent.h
+// @author Matthias Richter, Timm Steinbeck
+// @date
+// @brief Base class declaration for HLT components.
+// @note The class is both used in Online (PubSub) and Offline (AliRoot)
+// context
+
/**
* @defgroup alihlt_component Component handling of the HLT module
class AliHLTComponentHandler;
class TObjArray;
+class TMap;
class TStopwatch;
+class AliRawDataHeader;
class AliHLTComponent;
class AliHLTMemoryFile;
+class AliHLTCTPData;
+class AliHLTReadoutList;
/** list of component data type structures */
typedef vector<AliHLTComponentDataType> AliHLTComponentDataTypeList;
* If the component has multiple output data types @ref GetOutputDataType
* should return @ref kAliHLTMultipleDataType. The framework will invoke
* @ref GetOutputDataTypes, a list can be filled.
+ * - @ref Reconfigure
+ * This function is invoked by the framework on a special event which
+ * triggers the reconfiguration of the component.
*
* @subsection alihltcomponent-processing-mehods Data processing
*
* framework will allocate a buffer of appropriate size and call the processing
* again.
*
- * @subsection alihltcomponent-error-codes Data processing
+ * @subsection alihltcomponent-error-codes Return values/Error codes
* For return codes, the following scheme applies:
* - The data processing methods have to indicate error conditions by a negative
* error/return code. Preferably the system error codes are used like
* <pre>
* \#include \<cerrno\>
* </pre>
+ * This schema aplies to all interface functions of the component base class.
+ * For data processing it is as follows:
* - If no suitable input block could be found (e.g. no clusters for the TPC cluster
* finder) set size to 0, block list is empty, return 0
* - If no ususable or significant signal could be found in the input blocks
* - @ref AliHLTDataSource::GetEvent
* - @ref AliHLTDataSink::DumpEvent
*
- *
+ * The base class passes all relevant parameters for data access directly on to the
+ * component. Input blocks can be accessed by means of the array <tt> blocks </tt>.
+ * Output data are written directly to shared memory provided by the pointer
+ * <tt> outputPtr </tt> and output block descriptors are inserted directly to the
+ * list <tt> outputBlocks </tt>.
+ *
+ * \b NOTE: The high-level input data access methods can be used also from the low
+ * level interface. Also the PushBack functions can be used BUT ONLY if no data is
+ * written to the output buffer and no data block descriptors are inserted into the
+ * output block list.
+ *
+ * @section alihltcomponent-initialization Component initialization and configuration
+ * The component interface provides two optional methods for component initialization
+ * and configuration. The @ref DoInit function is called once before the processing.
+ * During the event processing, a special event can trigger a reconfiguration and the
+ * @ref Reconfigure method is called. There are three possible options of initialization
+ * and configuration:
+ * - default values: set directly in the source code
+ * - OCDB objects: all necessary information must be loaded from OCDB objects. The
+ * Offline Conditions Data Base stores objects specifically valid for individual runs
+ * or run ranges.
+ * - Component arguments: can be specified for every component in the chain
+ * configuration. The arguments can be used to override specific parameters of the
+ * component.
+ *
+ * As a general rule, the three options should be processed in that sequence, i.e
+ * default parameters might be overridden by OCDB configuration, and the latter one
+ * by component arguments.
+ *
+ * @subsection alihltcomponent-initialization-arguments Component arguments
+ * In normal operation, components are supposed to run without any additional argument,
+ * however such arguments can be useful for testing and debugging. The idea follows
+ * the format of command line arguments. A keyword is indicated by a dash and an
+ * optional argument might follow, e.g.:
+ * <pre>
+ * -argument1 0.5 -argument2
+ * </pre>
+ * In this case argument1 requires an additional parameter whereas argument2 does not.
+ * The arguments will be provided as an array of separated arguments.
+ *
+ * Component arguments can be classified into initialization arguments and configuration
+ * arguments. The latter are applicable for both the @ref DoInit and @ref Reconfigure
+ * method whereas initialization arguments are not applicable after DoInit.
+ *
+ * @subsection alihltcomponent-initialization-ocdb OCDB objects
+ * OCDB objects are ROOT <tt>TObjects</tt> and can be of any type. This is in particular
+ * useful for complex parameter sets. However in most cases, a simple approach of human
+ * readable command line arguments is appropriate. Such a string can be simply stored
+ * in a TObjString (take note that the TString does not derive from TObject). The
+ * same arguments as for the command line can be used. Take note that in the TObjString
+ * all arguments are separated by blanks, instead of being in an array of separate
+ * strings.
+ *
+ * The base class provides two functions regarding OCDB objects:
+ * - LoadAndExtractOCDBObject() loads the OCDB entry for the specified path and extracts
+ * the TObject from it.
+ * - ConfigureFromCDBTObjString() can load a number of OCDB objects and calls the
+ * argument parsing ConfigureFromArgumentString
+ *
+ *
+ * @subsection alihltcomponent-initialization-sequence Initialization sequence
+ * Using the approach of <tt>TObjString</tt>-type configuration objects allows to treat
+ * configuration from both @ref DoInit and @ref Reconfigure in the same way.
+ *
+ * The base class provides the function ConfigureFromArgumentString() which loops over
+ * all arguments and calls the child's method ScanConfigurationArgument(). Here the
+ * actual treatment of the argument and its parameters needs to be implemented.
+ * ConfigureFromArgumentString() can treat both arrays of arguments and arguments in
+ * one single string separated by blanks. The two options can be mixed.
+ *
+ * A second bas class function ConfigureFromCDBTObjString() allows to configure
+ * directly from a number of OCDB objects. This requires the entries to be of
+ * type TObjString and the child implementation of ScanConfigurationArgument().
+ *
* @section alihltcomponent-handling Component handling
* The handling of HLT analysis components is carried out by the AliHLTComponentHandler.
* Component are registered automatically at load-time of the component shared library
* under the following suppositions:
* - the component library has to be loaded from the AliHLTComponentHandler using the
* @ref AliHLTComponentHandler::LoadLibrary method.
+ * - the library defines an AliHLTModuleAgent which registers all components.
+ * See AliHLTModuleAgent::RegisterComponents <br>
+ * or <br>
* - the component implementation defines one global object (which is generated
- * when the library is loaded)
+ * when the library is loaded) <br>
*
* @subsection alihltcomponent-design-rules General design considerations
* The analysis code should be implemented in one or more destict class(es). A
*
* Further rules:
* - avoid big static arrays in the component, allocate the memory at runtime
+ * - allocate all kind of complex data members (like classes, ROOT TObjects of
+ * any kind) dynamically in DoInit and clean up in DoDeinit
*
* @section alihlt_component_arguments Default arguments
* The component base class provides some default arguments:
* \li -object-compression=level <br>
* compression level for ROOT objects, default is defined by
* @ref ALIHLTCOMPONENT_DEFAULT_OBJECT_COMPRESSION
+ * \li -pushback-period=period <br>
+ * scale down for PushBack of objects, shipped only for one event
+ * every <i>period</i> seconds
*
* @ingroup alihlt_component
* @section alihltcomponent-members Class members
/**
* Init function to prepare data processing.
* Initialization of common data structures for a sequence of events.
- * The call is redirected to the internal method @ref DoInit which can be
- * overridden by the child class.<br>
+ * The call is redirected to the internal method DoInit which can be
+ * overridden by the child class.
* During Init also the environment structure is passed to the component.
- * @param environ environment pointer with environment dependend function
+ * @param comenv environment pointer with environment dependent function
* calls
- * @param environParam additionel parameter for function calls, the pointer
+ * @param environParam additional parameter for function calls, the pointer
* is passed as it is
* @param argc size of the argument array
- * @param argv agument array for component initialization
+ * @param argv augment array for component initialization
*/
- virtual int Init( const AliHLTAnalysisEnvironment* environ, void* environParam, int argc, const char** argv );
+ virtual int Init( const AliHLTAnalysisEnvironment* comenv, void* environParam, int argc, const char** argv );
/**
* Clean-up function to terminate data processing.
*/
int SetComponentDescription(const char* desc);
+ /**
+ * Set the running environment for the component.
+ * Originally, the environment was set in the Init function. However, the setup of
+ * the CDB is required before. In order to have proper logging functionality, the
+ * environment is required.
+ * @param comenv environment pointer with environment dependent function
+ * calls
+ * @param environParam additional parameter for function calls, the pointer
+ * is passed as it is
+ */
+ int SetComponentEnvironment(const AliHLTAnalysisEnvironment* comenv, void* environParam);
+
// Information member functions for registration.
/**
virtual int GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList);
/**
- * Get a ratio by how much the data volume is shrinked or enhanced.
+ * Get a ratio by how much the data volume is shrunken or enhanced.
* The function is pure virtual and must be implemented by the child class.
* @param constBase <i>return</i>: additive part, independent of the
* input data volume
*/
virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) = 0;
+ /**
+ * Get a list of OCDB object description.
+ * The list of objects is provided in a TMap
+ * - key: complete OCDB path, e.g. GRP/GRP/Data
+ * - value: short description why the object is needed
+ * Key and value objects created inside this class go into ownership of
+ * target TMap.
+ * @param targetMap TMap instance receiving the list
+ * @return void
+ */
+ virtual void GetOCDBObjectDescription( TMap* const targetArray);
+
/**
* Spawn function.
* Each component must implement a spawn function to create a new instance of
*/
virtual AliHLTComponent* Spawn() = 0;
+ /**
+ * check the availability of the OCDB entry descriptions in the TMap
+ * key : complete OCDB path of the entry
+ * value : auxiliary object - short description
+ * if the external map was not provided the function invokes
+ * interface function GetOCDBObjectDescription() to retrieve the list.
+ * @param externList map of entries to be tested
+ * @result 0 if all found, -ENOENT if objects not found
+ */
+ int CheckOCDBEntries(const TMap* const externList=NULL);
+
/**
* Find matching data types between this component and a consumer component.
* Currently, a component can produce only one type of data. This restriction is most
static int ExtractComponentTableEntry(const AliHLTUInt8_t* pBuffer, AliHLTUInt32_t size,
string& chainId, string& compId, string& compParam,
vector<AliHLTUInt32_t>& parents);
+
+ /**
+ * Extracts the different data parts from the trigger data structure.
+ * [in] @param trigData The trigger data as passed to the DoProcessing method.
+ * [out] @param attributes The data block attributes given by the HLT framework.
+ * [out] @param status The HLT status bits given by the HLT framework.
+ * [out] @param cdh The common data header received from DDL links.
+ * [out] @param readoutlist The readout list to fill with readout list bits
+ * passed on by the HLT framework.
+ * [in] @param printErrors If true then error messages are generated as necessary
+ * and suppressed otherwise.
+ * @note If any of the output parameters are set to NULL then the field is not set.
+ * For example, the following line will only fill the CDH pointer.
+ * \code
+ * AliRawDataHeader* cdh;
+ * ExtractTriggerData(trigData, NULL, NULL, &cdh, NULL);
+ * \endcode
+ * @return the zero on success and one of the following error codes on failure.
+ * if a non-zero error code is returned then none of the output parameters are
+ * modified.
+ * \li -ENOENT The <i>trigData</i> structure size is wrong.
+ * \li -EBADF The <i>trigData</i> data size is wrong.
+ * \li -EBADMSG The common data header (CDH) in the trigger data has the wrong
+ * number of words indicated.
+ * \li -EPROTO The readout list structure in the trigger data has the wrong
+ * number of words indicated.
+ */
+ static int ExtractTriggerData(
+ const AliHLTComponentTriggerData& trigData,
+ const AliHLTUInt8_t (**attributes)[gkAliHLTBlockDAttributeCount],
+ AliHLTUInt64_t* status,
+ const AliRawDataHeader** cdh,
+ AliHLTReadoutList* readoutlist,
+ bool printErrors = false
+ );
+
+ /**
+ * Extracts the readout list from a trigger data structure.
+ * [in] @param trigData The trigger data as passed to the DoProcessing method.
+ * [out] @param list The output readout list to fill.
+ * [in] @param printErrors If true then error messages are generated as necessary
+ * and suppressed otherwise.
+ * @return the zero on success or one of the error codes returned by ExtractTriggerData.
+ */
+ static int GetReadoutList(
+ const AliHLTComponentTriggerData& trigData, AliHLTReadoutList& list,
+ bool printErrors = false
+ )
+ {
+ return ExtractTriggerData(trigData, NULL, NULL, NULL, &list, printErrors);
+ }
+
/**
* Stopwatch type for benchmarking.
*/
* be started<br>
* 0 if it controls the same stopwatch
*/
- int Hold(TStopwatch* pSucc);
+ int Hold(const TStopwatch* pSucc);
/**
* Resume the previous guard.
* be stopped<br>
* 0 if it controls the same stopwatch
*/
- int Resume(TStopwatch* pSucc);
+ int Resume(const TStopwatch* pSucc);
/** the stopwatch controlled by this guard */
TStopwatch* fpStopwatch; //!transient
* part of a normal event, the component configuration is called first.
*
* The CDB path parameter specifies the path in the CDB, i.e. without
- * leading absolute path of the CDB location. The framework might alse
+ * leading absolute path of the CDB location. The framework might also
* provide the id of the component in the analysis chain.
*
+ * The actual sequence of configuration depends on the component. As a
+ * general rule, the component should load the specific OCDB object if
+ * provided as parameter, and load the default objects if the parameter
+ * is NULL. However, other schemes are possible. See @ref
+ *
* \b Note: The CDB will be initialized by the framework, either already set
* from AliRoot or from the wrapper interface during initialization.
*
*/
virtual int ReadPreprocessorValues(const char* modules);
+ /**
+ * Child implementation to scan a number of configuration arguments.
+ * The method is invoked by the framework in conjunction with the
+ * common framework functions ConfigureFromArgumentString and
+ * ConfigureFromCDBTObjString.
+ * Function needs to scan the argument and optional additional
+ * parameters and returns the number of elements in the array which
+ * have been treated.
+ * @param argc
+ * @param argv
+ * @return number of arguments which have been scanned or neg error
+ * code if failed <br>
+ * \li -EINVAL unknown argument
+ * \li -EPROTO protocol error, e.g. missing parameter
+ */
+ virtual int ScanConfigurationArgument(int argc, const char** argv);
+
/**
* Custom handler for the SOR event.
* Is invoked from the base class if an SOR event is in the block list.
* The handler is called before the processing function. The processing
* function is skipped if there are no other data blocks available.
*
- * See StartOfRun() for mor ecomments of the sequence of steering events.
+ * See StartOfRun() for more comments of the sequence of steering events.
*
* @return neg. error code if failed
*/
* framework. Function pointers are transferred via the @ref
* AliHLTAnalysisEnvironment structure.
*/
- int GetEventDoneData( unsigned long size, AliHLTComponentEventDoneData** edd );
+ int GetEventDoneData( unsigned long size, AliHLTComponentEventDoneData** edd ) const;
/**
* Allocate an EventDoneData structure for the current event .
* Get the pointer to the event done data available/built so far for the current event via
* @ref ReserveEventDoneData and @ref PushEventDoneData
*/
- AliHLTComponentEventDoneData* GetCurrentEventDoneData()
+ AliHLTComponentEventDoneData* GetCurrentEventDoneData() const
{
return fEventDoneData;
}
*/
void DataType2Text(const AliHLTComponentDataType& type, char output[kAliHLTComponentDataTypefIDsize+kAliHLTComponentDataTypefOriginSize+2]) const;
+ /**
+ * Loop through a list of component arguments.
+ * The list can be either an array of separated strings or one single
+ * string containing blank separated arguments, or both mixed.
+ * ScanConfigurationArgument() is called to allow the component to treat
+ * the individual arguments.
+ * @return neg. error code if failed
+ */
+ int ConfigureFromArgumentString(int argc, const char** argv);
+
+ /**
+ * Read configuration objects from OCDB and configure from
+ * the content of TObjString entries.
+ * @param entries blank separated list of OCDB paths
+ * @return neg. error code if failed
+ */
+ int ConfigureFromCDBTObjString(const char* entries);
+
+ /**
+ * Load specified entry from the OCDB and extract the object.
+ * The entry is explicitely unloaded from the cache before it is loaded.
+ * @param path path of the entry under to root of the OCDB
+ * @param version version of the entry
+ * @param subVersion subversion of the entry
+ */
+ TObject* LoadAndExtractOCDBObject(const char* path, int version = -1, int subVersion = -1);
+
+
/**
* Get event number.
* @return value of the internal event counter
/**
* Get the first object of a specific data type from the input data.
- * The hight-level methods provide functionality to transfer ROOT data
+ * The High-level methods provide functionality to transfer ROOT data
* structures which inherit from TObject.
*
* The method looks for the first ROOT object of type dt in the input stream.
* If also the class name is provided, the object is checked for the right
* class type. The input data block needs a certain structure, namely the
* buffer size as first word. If the cross check fails, the retrieval is
- * silently abondoned, unless the \em bForce parameter is set.<br>
+ * silently abandoned, unless the \em bForce parameter is set.<br>
* \b Note: THE OBJECT MUST NOT BE DELETED by the caller.
*
* If called without parameters, the function tries to create objects from
/**
* Get the first object of a specific data type from the input data.
- * The hight-level methods provide functionality to transfer ROOT data
+ * The High-level methods provide functionality to transfer ROOT data
* structures which inherit from TObject.
* The method looks for the first ROOT object of type specified by the ID and
* Origin strings in the input stream.
* If also the class name is provided, the object is checked for the right
* class type. The input data block needs a certain structure, namely the
* buffer size as first word. If the cross check fails, the retrieval is
- * silently abondoned, unless the \em bForce parameter is set.<br>
+ * silently abandoned, unless the \em bForce parameter is set.<br>
* \em Note: THE OBJECT MUST NOT BE DELETED by the caller.
* @param dtID data type ID of the object
* @param dtOrigin data type origin of the object
/**
* Get the next object of a specific data type from the input data.
- * The hight-level methods provide functionality to transfer ROOT data
+ * The High-level methods provide functionality to transfer ROOT data
* structures which inherit from TObject.
* The method looks for the next ROOT object of type and class specified
* to the previous @ref GetFirstInputObject call.<br>
/**
* Get data specification of an input block.
- * Get data specification of the input bblock previously fetched via
+ * Get data specification of the input block previously fetched via
* GetFirstInputObject/NextInputObject or the last one if no block
* specified.
* @param pBlock pointer to input block
* Insert an object into the output.
* If header is specified, it will be inserted before the root object,
* default is no header.
+ * The publishing can be downscaled by means of the -pushback-period
+ * parameter. This is especially useful for histograms which do not
+ * need to be sent for every event.
* @param pObject pointer to root object
* @param dt data type of the object
* @param spec data specification
* Insert an object into the output.
* If header is specified, it will be inserted before the root object,
* default is no header.
+ * The publishing can be downscaled by means of the -pushback-period
+ * parameter. This is especially useful for histograms which do not
+ * need to be sent for every event.
* @param pObject pointer to root object
* @param dtID data type ID of the object
* @param dtOrigin data type origin of the object
const char* GetChainId() const {return fChainId.c_str();}
/**
- * Check whether the current event is a valid data event.
- * @param pTgt optional pointer to get the event type
- * @return true if the current event is a real data event
+ * Get a timestamp of the current event
+ * Exact format needs to be documented.
*/
- bool IsDataEvent(AliHLTUInt32_t* pTgt=NULL);
+ AliHLTUInt32_t GetTimeStamp() const;
/**
- * Set a bit to 1 in a readout list ( = AliHLTEventDDL )
- * -> enable DDL for readout
- * @param list readout list
- * @param ddlId DDL Id to be turned on ( Decimal )
+ * Get the period number.
+ * Upper 28 bits (36 to 63) of the 64-bit event id
*/
- void EnableDDLBit(AliHLTEventDDL &list, Int_t ddlId ) const {
- SetDDLBit( list, ddlId, kTRUE );
- }
+ AliHLTUInt32_t GetPeriodNumber() const;
/**
- * Set a bit to 0 in a readout list ( = AliHLTEventDDL )
- * -> disable DDL for readout
- * @param list readout list
- * @param ddlId DDL Id to be turned on ( Decimal )
+ * Get the period number.
+ * 24 bits, 12 to 35 of the 64-bit event id
*/
- void DisableDDLBit(AliHLTEventDDL &list, Int_t ddlId ) const {
- SetDDLBit( list, ddlId, kFALSE );
- }
-
+ AliHLTUInt32_t GetOrbitNumber() const;
+
/**
- * Set or unset bit a readout list ( = AliHLTEventDDL )
- * -> enable or disable DDL for readout
- * @param list readout list
- * @param ddlId DDL Id to be turned on ( Decimal )
- * @param state kTRUE sets it, kFALSE unsets it
+ * Get the bunch crossing number.
+ * 12 bits, 0 to 12 of the 64-bit event id
*/
- void SetDDLBit(AliHLTEventDDL &list, Int_t ddlId, Bool_t state ) const;
-
+ AliHLTUInt16_t GetBunchCrossNumber() const;
+
/**
- * Get the first word of a detector, which has a set DDL bit.
- * Beware, this only works if DDLs of 1 detector are set. In the
- * case of the TPC and TOF, which use 8 and 3 words, the first
- * word is returned.
- * @param list readout list
- * @return returns the detector index, -1 if no bit is set
- * at all or several detectors (=error)
+ * Setup the CTP accounting functionality of the base class.
+ * The method can be invoked from DoInit() for componenets which want to
+ * use the CTP functionality of the base class.
+ *
+ * The AliHLTCTPData is initialized with the trigger classes from the ECS
+ * parameters. The base class automatically increments the counters according
+ * to the trigger pattern in the CDH before the event processing.
*/
- Int_t GetFirstUsedDDLWord(AliHLTEventDDL &list) const;
+ int SetupCTPData();
+
+ /**
+ * Get the instance of the CTP data.
+ */
+ const AliHLTCTPData* CTPData() const {return fpCTPData;}
+
+ /**
+ * Check whether a combination of trigger classes is fired.
+ * The expression can contain trigger class ids and logic operators
+ * like &&, ||, !, and ^, and may be grouped by parentheses.
+ * @note the function requires the setup of the CTP handling for the component by
+ * invoking SetupCTPData() from DoInit()
+ * @param expression a logic expression of trigger class ids
+ * @param trigData the trigger data data
+ */
+ bool EvaluateCTPTriggerClass(const char* expression, AliHLTComponentTriggerData& trigData) const;
+
+ /**
+ * Check state of a trigger class.
+ * If the class name is not part of the current trigger setup (i.e. ECS parameter
+ * does not contain a trigger definition for this class name) the function
+ * returns -1
+ * @note the function requires the setup of the CTP handling for the component by
+ * invoking SetupCTPData() from DoInit()
+ * @return -1 class name not initialized,
+ * 0 trigger not active
+ * 1 trigger active
+ */
+ int CheckCTPTrigger(const char* name) const;
+
+ /**
+ * Get the overall solenoid field.
+ */
+ Double_t GetBz();
+ /**
+ * Get the solenoid field at point r.
+ */
+ Double_t GetBz(const Double_t *r);
+ /**
+ * Get the solenoid field components at point r.
+ */
+ void GetBxByBz(const Double_t r[3], Double_t b[3]);
+
+ /**
+ * Check whether the current event is a valid data event.
+ * @param pTgt optional pointer to get the event type
+ * @return true if the current event is a real data event
+ */
+ bool IsDataEvent(AliHLTUInt32_t* pTgt=NULL) const;
/**
* Copy a struct from block data.
AliHLTUInt32_t offset,
const vector<AliHLTUInt32_t>& parents) const;
+ /**
+ * Scan the ECS parameter string.
+ * The framework provides both the parameters of CONFIGURE and ENGAGE
+ * in one string in a special data block kAliHLTDataTypeECSParam
+ * {ECSPARAM:PRIV}. The general format is
+ * <command>;<parameterkey>=<parametervalue>;<parameterkey>=<parametervalue>;...
+ */
+ int ScanECSParam(const char* ecsParam);
+
+ /**
+ * The trigger classes are determined from the trigger and propagated by
+ * ECS as part of the ENGAGE command parameter which is sent through the
+ * framework during the SOR event. This function treats the value of the
+ * parameter key CTP_TRIGGER_CLASS.
+ */
+ int InitCTPTriggerClasses(const char* ctpString);
+
+ enum {
+ kRequireSteeringBlocks = 0x1,
+ kDisableComponentStat = 0x2
+ };
+
/** The global component handler instance */
static AliHLTComponentHandler* fgpComponentHandler; //! transient
/** descriptor of the current run */
AliHLTRunDesc* fpRunDesc; //! transient
- /** the current DDL list */
- AliHLTEventDDL* fpDDLList; //! transient
-
/** external fct to set CDB run no, indicates external CDB initialization */
void (*fCDBSetRunNoFunc)(); //! transient
/** optional benchmarking for the component statistics */
TStopwatch* fpBenchmark; //! transient
- /** component requires steering data blocks */
- bool fRequireSteeringBlocks; //! transient
+ /** component flags, cleared in Deinit */
+ AliHLTUInt32_t fFlags; //! transient
/** current event type */
AliHLTUInt32_t fEventType; //! transient
/** size of last PushBack-serialized object */
int fLastObjectSize; //! transient
- ClassDef(AliHLTComponent, 10)
+ /** array of trigger class descriptors */
+ AliHLTCTPData* fpCTPData; //! transient
+
+ /// update period for PushBack calls
+ int fPushbackPeriod; //! transient
+ /// time of last executed PushBack
+ int fLastPushBackTime; //! transient
+
+ ClassDef(AliHLTComponent, 14)
};
#endif
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff