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 *
11 @author Matthias Richter
13 @brief The control class for HLTOUT data.
17 #include "AliHLTLogging.h"
18 #include "AliHLTModuleAgent.h"
20 class AliHLTOUTHandler;
21 class AliHLTOUTHandlerDesc; // AliHLTModuleAgent.h
23 class AliHLTReconstructor;
27 #define AliHLTOUTInvalidIndex (~(AliHLTUInt32_t)0)
29 typedef vector<AliHLTUInt32_t> AliHLTOUTIndexList;
33 * The control class for HLTOUT data.
34 * The output of the HLT, either from the HLTOUT nodes or simulated output,
35 * is transferred and stored in the HOMER format. The AliHLTOUT class
36 * implements scanning of the HOMER data for all HLTOUT DDL links and
37 * abstracts access to the complete HLTOUT data.
42 /** standard constructor */
44 /** standard destructor */
48 * Create an AliHLTOUTRawReader instance.
49 * Helper function to transparently access classes from the
52 static AliHLTOUT* New(AliRawReader* pRawReader);
55 * Create an AliHLTOUTDigitReader instance
56 * Helper function to transparently access classes from the
59 static AliHLTOUT* New(TTree* pDigitTree, int event=-1);
62 * Create an AliHLTOUTDigitReader instance
63 * Helper function to transparently access classes from the
66 static AliHLTOUT* New(const char* filename, int event=-1);
69 * Get the global instance.
70 * The global instance is set temporarily by the AliHLTOUTGlobalInstanceGuard
71 * mainly for the sake of data input to an analysis chain. The
72 * AliHLTOUTPublisherComponent objects can access the global instance.
74 static AliHLTOUT* GetGlobalInstance() {return fgGlobalInstance;}
77 * Delete an instance of the HLTOUT.
78 * Helper function to transparently access classes from the
79 * libHLTrec library. Before deleting, the availability of the
82 static void Delete(AliHLTOUT* pInstance);
85 * Locking guard for the AliHLTOUT object.
86 * If the object is locked, the selection of data blocks can not be changed.
88 class AliHLTOUTLockGuard {
91 AliHLTOUTLockGuard(AliHLTOUT* pInstance) : fpInstance(pInstance)
92 {if (fpInstance) fpInstance->SetStatusFlag(kLocked);}
95 {if (fpInstance) fpInstance->ClearStatusFlag(kLocked);}
98 /** standard constructor prohibited */
100 /** copy constructor prohibited */
101 AliHLTOUTLockGuard(const AliHLTOUTLockGuard&);
102 /** assignment operator prohibited */
103 AliHLTOUTLockGuard& operator=(const AliHLTOUTLockGuard&);
105 /** the AliHLTOUT instance the guard is locking */
106 AliHLTOUT* fpInstance; //!transient
110 * Guard for handling of global AliHLTOUT instance.
111 * The global HLTOUT instance can be set for certain steps of the
112 * processing. The initial objective is to support input to the
113 * AliHLTOUTPublisherComponent running in a kChain handler.
115 * The Guard restores the original instance when closed.
117 class AliHLTOUTGlobalInstanceGuard {
120 AliHLTOUTGlobalInstanceGuard(AliHLTOUT* pInstance) : fpLastInstance(AliHLTOUT::fgGlobalInstance)
121 {AliHLTOUT::fgGlobalInstance=pInstance;}
123 ~AliHLTOUTGlobalInstanceGuard()
124 {AliHLTOUT::fgGlobalInstance=fpLastInstance;}
127 /** standard constructor prohibited */
128 AliHLTOUTGlobalInstanceGuard();
129 /** copy constructor prohibited */
130 AliHLTOUTGlobalInstanceGuard(const AliHLTOUTGlobalInstanceGuard&);
131 /** assignment operator prohibited */
132 AliHLTOUTGlobalInstanceGuard& operator=(const AliHLTOUTGlobalInstanceGuard&);
134 /** the AliHLTOUT instance the guard is locking */
135 AliHLTOUT* fpLastInstance; //!transient
139 * The HLT OUT Event Header.
140 * Defined between HLT and DAQ.
142 struct AliHLTOUTEventHeader {
143 /**Total length of the data in bytes, including HLT event header, excluding CDH. */
144 AliHLTUInt32_t fLength; //! see above
145 /** version of the header */
146 AliHLTUInt32_t fVersion; //! see above
147 /** High 32 bit word of event id */
148 AliHLTUInt32_t fEventIDHigh; //! see above
149 /** Low 32 bit word of event id */
150 AliHLTUInt32_t fEventIDLow; //! see above
154 /// versions 1 of the HLT header
156 /// versions 2 of the HLT header
161 /// size of HLT decision in data format version 1: 29x4
162 kSizeDecisionVersion1 = 116,
163 /// size of HLT decision in data format version 2: 30x4
164 kSizeDecisionVersion2 = 120
167 // definitions from ALICE internal notes ALICE-INT-2002-010 and
168 // ALICE-INT-2006-XXX
170 /** the 32bit word in the CDH containing the status flags */
171 kCDHStatusWord=4, //! see above
172 /** start of the flags in word fgkCDHStatusWord */
173 kCDHStatusFlagsOffset=12, //! see above
174 /** bit indicating HLT decision in the HLTOUT*/
175 kCDHFlagsHLTDecision=6, //! see above
176 /** bit indicating HLT payload in the HLTOUT*/
177 kCDHFlagsHLTPayload=7 //! see above
180 class AliHLTOUTHandlerListEntry;
184 class AliHLTOUTBlockDescriptor {
186 AliHLTOUTBlockDescriptor(AliHLTComponentDataType dt, AliHLTUInt32_t spec, AliHLTUInt32_t index, AliHLTOUT* pCollection)
187 : fDataType(dt), fSpecification(spec), fIndex(index), fSelected(false), fProcessed(false), fpCollection(pCollection) {};
188 AliHLTOUTBlockDescriptor(const AliHLTOUTBlockDescriptor& src)
189 : fDataType(src.fDataType), fSpecification(src.fSpecification), fIndex(src.fIndex), fSelected(false), fProcessed(false), fpCollection(src.fpCollection) {}
190 AliHLTOUTBlockDescriptor& operator=(const AliHLTOUTBlockDescriptor& src)
191 { fDataType=src.fDataType; fSpecification=src.fSpecification; fIndex=src.fIndex; fSelected=false; fProcessed=false; fpCollection=src.fpCollection; return *this; }
192 ~AliHLTOUTBlockDescriptor() {}
194 operator AliHLTComponentDataType() const {return fDataType;}
195 operator AliHLTUInt32_t() const {return fSpecification;}
196 int operator==(AliHLTComponentDataType dt) const {return dt==fDataType;}
197 int operator==(AliHLTUInt32_t spec) const {return spec==fSpecification;}
198 int operator==(AliHLTOUT* collection) const {return collection==fpCollection;}
200 AliHLTUInt32_t GetIndex() const {return fIndex;}
201 AliHLTOUT* GetCollection() const {return fpCollection;}
203 bool IsSelected() const {return fSelected;}
204 void Select(bool selected=true) {fSelected=selected;}
205 bool IsProcessed() const {return fProcessed;}
206 void MarkProcessed() {fProcessed=true;}
209 * Get the data buffer
210 * @param [out] pBuffer buffer of the selected data block
211 * @param [out] size size of the selected data block
213 int GetDataBuffer(const AliHLTUInt8_t* &pBuffer, AliHLTUInt32_t& size) {
214 if (fpCollection) return fpCollection->GetDataBuffer(GetIndex(), pBuffer, size);
219 * Get the handler descriptor
221 const AliHLTOUTHandlerListEntry& GetHandlerDesc();
224 /** data type of the block */
225 AliHLTComponentDataType fDataType; //!transient
226 /** data specification of the block */
227 AliHLTUInt32_t fSpecification; //!transient
228 /** index in the data stream */
229 AliHLTUInt32_t fIndex; //!transient
230 /** selection flag */
231 bool fSelected; //!transient
232 /** processed flag */
233 bool fProcessed; //!transient
234 /** the collection */
235 AliHLTOUT* fpCollection; //!transient
238 class AliHLTOUTHandlerListEntry {
240 AliHLTOUTHandlerListEntry(AliHLTOUTHandler* pHandler,
241 AliHLTModuleAgent::AliHLTOUTHandlerDesc& handlerDesc,
242 AliHLTModuleAgent* pAgent,
243 AliHLTUInt32_t index);
245 /** copy constructor for vector handling */
246 AliHLTOUTHandlerListEntry(const AliHLTOUTHandlerListEntry& src);
248 /** assignment operator for vector handling */
249 AliHLTOUTHandlerListEntry& operator=(const AliHLTOUTHandlerListEntry& src);
251 ~AliHLTOUTHandlerListEntry();
253 static const AliHLTOUTHandlerListEntry fgkVoidHandlerListEntry; //! initializer
255 operator AliHLTOUTHandler*() const {return fpHandler;}
257 // please note that fpHandlerDesc is really a pointer and is created
258 // in the constructor. Thats why it is dereferenced here. The pointer
259 // type is on purpose, even though it is a bit confusing with the
260 // argument by reference in the AliHLTOUTHandlerListEntry constructor.
261 operator const AliHLTModuleAgent::AliHLTOUTHandlerDesc&() const
262 {return fpHandlerDesc?*fpHandlerDesc:AliHLTModuleAgent::fgkVoidHandlerDesc;}
263 operator AliHLTModuleAgent*() const {return fpAgent;}
266 * Two list entries are considered to be equal if the handlers
269 bool operator==(const AliHLTOUTHandlerListEntry& entry) const;
271 bool operator==(const AliHLTModuleAgent::AliHLTOUTHandlerType handlerType) const;
274 * Compare the handler descriptor of this list entry with another
276 * @return true if both handler and agent match
278 bool operator==(const AliHLTModuleAgent::AliHLTOUTHandlerDesc desc) const;
280 AliHLTUInt32_t operator[](int i) const;
283 * Add a block index to this descriptor.
284 * One descriptor can serve multiple blocks if the agent returns the
285 * same handler for all of the blocks. Instead of creating a new entry
286 * the block index ist just added
288 void AddIndex(AliHLTUInt32_t index);
291 * Add all indices of the descriptor.
293 void AddIndex(AliHLTOUTHandlerListEntry &desc);
296 * Check if an index is served by this descriptor.
297 * @return true if the index is in the table
299 bool HasIndex(AliHLTUInt32_t index) const;
302 * Invalidate all block indices
304 void InvalidateBlocks() {fBlocks.clear();}
307 * Check whether the entry has valid blocks.
309 bool IsEmpty() {return fBlocks.size()==0;}
312 /** standard constructor prohibited */
313 AliHLTOUTHandlerListEntry();
315 /** pointer to the handler */
316 AliHLTOUTHandler* fpHandler; //! transient
318 /** pointer to handler description */
319 AliHLTModuleAgent::AliHLTOUTHandlerDesc* fpHandlerDesc; //! transient
321 /** pointer to module agent */
322 AliHLTModuleAgent* fpAgent; //! transient
324 /** list of block indices */
325 AliHLTOUTIndexList fBlocks; //!transient
328 typedef vector<AliHLTOUTHandlerListEntry> AliHLTOUTHandlerListEntryVector;
329 typedef vector<AliHLTOUTBlockDescriptor> AliHLTOUTBlockDescriptorVector;
330 typedef vector<AliHLTOUT*> AliHLTOUTPVector;
333 * Selection guard for the AliHLTOUT object.
334 * If the object is locked, the selection of data blocks can not be changed.
336 class AliHLTOUTSelectionGuard {
339 AliHLTOUTSelectionGuard(AliHLTOUT* pInstance) : fpInstance(pInstance)
340 {if (fpInstance) fpInstance->SelectDataBlock();}
342 AliHLTOUTSelectionGuard(AliHLTOUT* pInstance, const AliHLTOUTHandlerListEntry* pHandlerDesc) : fpInstance(pInstance)
343 {if (fpInstance) fpInstance->SelectDataBlocks(pHandlerDesc);}
345 ~AliHLTOUTSelectionGuard()
346 {if (fpInstance) fpInstance->DisableBlockSelection();}
349 /** standard constructor prohibited */
350 AliHLTOUTSelectionGuard();
351 /** copy constructor prohibited */
352 AliHLTOUTSelectionGuard(const AliHLTOUTSelectionGuard&);
353 /** assignment operator prohibited */
354 AliHLTOUTSelectionGuard& operator=(const AliHLTOUTSelectionGuard&);
356 /** the AliHLTOUT instance the guard is locking */
357 AliHLTOUT* fpInstance; //!transient
361 * Init for processing.
362 * The HLTOUT is scanned for all available data blocks and the
363 * AliHLTOUTHandler objects for the data blocks are created according
364 * to the module agents (see AliHLTModuleAgent).
369 * Reset and clear all data block descriptors.
370 * @note Since sub-collections are only referred via the block
371 * descriptors, all information on sub-collections is also lost.
372 * Child classes should implement ResetInput in order to cleanup
378 * Get the current event id
380 AliHLTUInt64_t EventId() {return fCurrentEventId;}
383 * Get number of data blocks in the HLTOUT data
385 int GetNofDataBlocks();
388 * Select the first data block of a certain data type and specification.
389 * The selection criteria can be of kAliHLTAnyDataType and/or
390 * kAliHLTVoidDataSpec in order to be ignored and just match any data block.
392 * The search criteria can be combined with a handler type (e.g. kRawReader)
393 * @param [in] dt data type to match <br>
394 * @param [in] spec data specification to match <br>
395 * @param [in] handlerType type of the handler
396 * @param [in] skipProcessed skip all block marked processed
397 * @return block index: >= 0 if success, -ENOENT if no block found <br>
398 * neg. error code if failed <br>
399 * -EPERM if access denied (object locked)
401 int SelectFirstDataBlock(AliHLTComponentDataType dt=kAliHLTAnyDataType,
402 AliHLTUInt32_t spec=kAliHLTVoidDataSpec,
403 AliHLTModuleAgent::AliHLTOUTHandlerType handlerType=AliHLTModuleAgent::kUnknownOutput,
404 bool skipProcessed=true);
407 * Select the next data block of data type and specification of the previous
408 * call to @ref SelectFirstDataBlock.
409 * @return block index: >= 0 if success, -ENOENT if no block found <br>
410 * neg. error code if failed <br>
411 * -EPERM if access denied (object locked)
413 int SelectNextDataBlock();
416 * Get properties of the selected data block.
417 * @param [out] dt data type of the selected block
418 * @param [out] spec data specification of the selected block
420 int GetDataBlockDescription(AliHLTComponentDataType& dt, AliHLTUInt32_t& spec);
423 * Get handler description of the current data block.
425 const AliHLTOUTHandlerListEntry& GetDataBlockHandlerDesc();
428 * Get handler type of the selected data block.
429 * @return handler type for the selected data block
431 AliHLTModuleAgent::AliHLTOUTHandlerType GetDataBlockHandlerType();
434 * Get the index of the current data block.
435 * @return index, AliHLTOUTInvalidIndex if no block selected
437 AliHLTUInt32_t GetDataBlockIndex();
440 * Get buffer of the selected data block.
441 * @param [out] pBuffer buffer of the selected data block
442 * @param [out] size size of the selected data block
444 int GetDataBuffer(const AliHLTUInt8_t* &pBuffer, AliHLTUInt32_t& size);
447 * Release buffer after use.
448 * @param [in] pBuffer buffer of the selected data block
450 int ReleaseDataBuffer(const AliHLTUInt8_t* pBuffer);
453 * Get a TObject from the data buffer
454 * @return TObject pointer if data block is a streamed object
456 TObject* GetDataObject();
459 * Release data object
461 int ReleaseDataObject(TObject* pObject);
464 * Add the current data block to the selection.
465 * Note: enables also the block selection
467 int SelectDataBlock();
470 * Add the all data blocks of a certain handler to the selection.
471 * Note: enables also the block selection
473 int SelectDataBlocks(const AliHLTOUTHandlerListEntry* pHandlerDesc);
476 * Enable the selection of data blocks.
478 int EnableBlockSelection();
481 * Disable the selection of data blocks.
483 int DisableBlockSelection();
486 * Reset the data block selection.
487 * Resets the selection list, none of the blocks is selected.
489 int ResetBlockSelection();
492 * Mark the current block as processed.
494 int MarkDataBlockProcessed();
497 * Mark all data blocks of a certain handler processed.
499 int MarkDataBlocksProcessed(const AliHLTOUTHandlerListEntry* pHandlerDesc);
502 * Add a sub collection to the HLTOUT.
504 int AddSubCollection(AliHLTOUT* pCollection);
507 * Release a previously added sub collection.
509 int ReleaseSubCollection(AliHLTOUT* pCollection);
512 * Get module agent for the selected data block.
514 AliHLTModuleAgent* GetAgent();
517 * Get handler for the selected data block.
519 AliHLTOUTHandler* GetHandler();
522 * Convert data buffer to ESD.
523 * The buffer is supposed to describe a streamed AliESDEvent object.
524 * If no target object is specified, the ESD is written to a file AliHLTdetESDs.root,
525 * where 'det' is derived from the data type origin. Each time the function is invoked
526 * a new event is created. Dummy events are added if the previous events did not contain
528 * The function needs AliRoot and might not be implemented by all AliHLTOUT
530 * a data block of this specification.
531 * @param [in] pBuffer the data buffer
532 * @param [in] size data buffer size
533 * @param [in] dt data type of the block
534 * @param [out] tgtesd optional target
536 virtual int WriteESD(const AliHLTUInt8_t* pBuffer, AliHLTUInt32_t size, AliHLTComponentDataType dt, AliESDEvent* tgtesd=NULL) const;
538 enum AliHLTOUTByteOrder {
539 /** no data block selected */
540 kInvalidByteOrder=-1,
546 enum AliHLTOUTDataType {
556 * Check byte order of selected block
558 AliHLTOUTByteOrder CheckByteOrder();
561 * Check alignment of selected block
563 int CheckAlignment(AliHLTOUT::AliHLTOUTDataType type);
566 * Helper function to byte swap a 64 bit value.
568 static AliHLTUInt64_t ByteSwap64(AliHLTUInt64_t src);
571 * Helper function to byte swap a 32 bit value.
573 static AliHLTUInt32_t ByteSwap32(AliHLTUInt32_t src);
576 * Insert a handler item.
577 * The current list entries are checked if the handler is already in
578 * the list. It is added if not in the list, otherwise the block index
579 * is added to the existing entry.
580 * @param list the handler list
581 * @param entry handler list entry
582 * @return 0 if added, EEXIST (non negative!) if merged with existing entry <br>
583 * neg. error code if failed
585 static int InsertHandler(AliHLTOUTHandlerListEntryVector& list, const AliHLTOUTHandlerListEntry &entry);
588 * Insert all handlers of the specified type to the list.
590 int FillHandlerList(AliHLTOUTHandlerListEntryVector& list, AliHLTModuleAgent::AliHLTOUTHandlerType handlerType);
593 * Remove empty items which have a duplicate in the list.
595 static int RemoveEmptyDuplicateHandlers(AliHLTOUTHandlerListEntryVector& list);
598 * Find an entry of a certain description in the list.
599 * @return index of the entry if found, -ENOENT if not found
601 static int FindHandler(AliHLTOUTHandlerListEntryVector& list, const AliHLTModuleAgent::AliHLTOUTHandlerDesc desc);
604 * Invalidate all blocks of the handlers in the list
606 static int InvalidateBlocks(AliHLTOUTHandlerListEntryVector& list);
610 * Add a block descriptor.
611 * This is done by the child classes generating the index. The AliHLTOUT
612 * object must be locked for index generation.
613 * @param desc the block descriptor
614 * @return 0 if success, -EPERM if access denied
616 int AddBlockDescriptor(const AliHLTOUTBlockDescriptor desc);
619 * Set the event id, only for child classes
621 void SetEventId(AliHLTUInt64_t id);
624 * Print output or suppress.
626 bool BeVerbose() {return fbVerbose;}
631 void SwitchVerbosity(bool verbose) {fbVerbose=verbose;}
634 /** copy constructor prohibited */
635 AliHLTOUT(const AliHLTOUT&);
636 /** assignment operator prohibited */
637 AliHLTOUT& operator=(const AliHLTOUT&);
640 * Internal status flags
643 /** the HLTOUT object is locked with the current data block selection */
645 /** childs can add block descriptors */
647 /** user of the data block has checked the byte order */
648 kByteOrderChecked = 0x4,
649 /** warning on byte order missmatch has been printed */
650 kByteOrderWarning = 0x8,
651 /** user of the data block has checked the alignment */
652 kAlignmentChecked = 0x10,
653 /** warning on alignment missmatch has been printed */
654 kAlignmentWarning = 0x20,
655 /** enable block selection list */
656 kBlockSelection = 0x40,
657 /** skip processed data blocks */
658 kSkipProcessed = 0x80,
659 /** marked as sub collection */
660 kIsSubCollection = 0x100
664 * Generate the index of the HLTOUT data.
665 * Must be implemented by the child classes.
667 virtual int GenerateIndex()=0;
670 * Find AliHLTOUTHandler objects for the data blocks.
671 * The available AliHLTModuleAgents are probed whether they provide
672 * handlers for data processing.
677 * Cleanup and reset the data input.
679 virtual int ResetInput();
682 * Get the data buffer
683 * @param [in] index index of the block
684 * @param [out] pBuffer buffer of the selected data block
685 * @param [out] size size of the selected data block
687 virtual int GetDataBuffer(AliHLTUInt32_t index, const AliHLTUInt8_t* &pBuffer,
688 AliHLTUInt32_t& size)=0;
691 * Check byte order of data block
693 virtual AliHLTOUTByteOrder CheckBlockByteOrder(AliHLTUInt32_t index)=0;
696 * Check alignment of data block
698 virtual int CheckBlockAlignment(AliHLTUInt32_t index, AliHLTOUT::AliHLTOUTDataType type)=0;
701 * Select the data block of data type and specification of the previous
702 * call to @ref SelectFirstDataBlock. Core function of @ref SelectFirstDataBlock
703 * and @ref SelectNextDataBlock, starts to find a block at the current list
706 * The data block is searched from the conditions of fSearchDataType,
707 * fSearchSpecification, fSearchHandlerType and the selection list.
709 * @return identifier >=0 if success, neg. error code if failed <br>
710 * -ENOENT if no block found <br>
711 * -EPERM if access denied (object locked)
713 int FindAndSelectDataBlock();
717 * @param flag flag to set
718 * @return current status flags
720 unsigned int SetStatusFlag(unsigned int flag) {return fFlags|=flag;}
724 * @param flag flag to clear
725 * @return current status flags
727 unsigned int ClearStatusFlag(unsigned int flag) {return fFlags&=~flag;}
731 * @param flag flag to check
732 * @return 1 if flag is set
734 int CheckStatusFlag(unsigned int flag) const {return (fFlags&flag)==flag;}
737 * Find handler description for a certain block index.
739 const AliHLTOUTHandlerListEntry& FindHandlerDesc(AliHLTUInt32_t blockIndex);
742 * Set the RawReader as parameter.
743 * The function is for internal use only in conjunction with the
746 virtual void SetParam(AliRawReader* pRawReader);
749 * Set the RunLoader as parameter
750 * The function is for internal use only in conjunction with the
753 virtual void SetParam(TTree* pDigitTree, int event=-1);
756 * Set name of the digit file as parameter
757 * The function is for internal use only in conjunction with the
760 virtual void SetParam(const char* filename, int event=-1);
762 /** data type for the current block search, set from @ref SelectFirstDataBlock */
763 AliHLTComponentDataType fSearchDataType; //!transient
765 /** data specification for the current block search */
766 AliHLTUInt32_t fSearchSpecification; //!transient
768 /** handler type for the current block search */
769 AliHLTModuleAgent::AliHLTOUTHandlerType fSearchHandlerType; // !transient
771 /** instance flags: locked, collecting, ... */
772 unsigned int fFlags; //!transient
774 /** list of block descriptors */
775 AliHLTOUTBlockDescriptorVector fBlockDescList; //!transient
777 /** current position in the list */
778 unsigned int fCurrent; //!transient
780 /** data buffer under processing */
781 const AliHLTUInt8_t* fpBuffer; //!transient
783 /** list of AliHLTOUTHandlers */
784 AliHLTOUTHandlerListEntryVector fDataHandlers; // !transient
786 /** verbose or silent output */
787 bool fbVerbose; //!transient
789 /** gobal instance set for certain steps of the analysis */
790 static AliHLTOUT* fgGlobalInstance; //! transient
792 /** logging methods */
793 AliHLTLogging fLog; //! transient
795 /** current buffer converted to a TObject */
796 TObject* fpDataObject; //!
797 const AliHLTUInt8_t* fpObjectBuffer; //!
798 AliHLTUInt32_t fObjectBufferSize; //!
800 /** current event id */
801 AliHLTUInt64_t fCurrentEventId; //!
803 ClassDef(AliHLTOUT, 6)