0a7c8cd3ff4ed7fa428fd6126b89cfc542e54ac8
[u/mrichter/AliRoot.git] / HLT / BASE / AliHLTDataTypes.h
1 // @(#) $Id$
2
3 #ifndef ALIHLTDATATYPES_H
4 #define ALIHLTDATATYPES_H
5 /* This file is property of and copyright by the ALICE HLT Project        * 
6  * ALICE Experiment at CERN, All rights reserved.                         *
7  * See cxx source for full Copyright notice                               */
8
9 /** @file   AliHLTDataTypes.h
10     @author Matthias Richter, Timm Steinbeck, Jochen Thaeder
11     @date   
12     @brief  Data type declaration for the HLT module.
13 */
14
15 //////////////////////////////////////////////////////////////////////////
16 //
17 // version no of HLT data types
18 //
19 //////////////////////////////////////////////////////////////////////////
20
21 /* Version   Description
22  *   1       first version until June 07; implicite, not tagged
23  *   2       introduced June 07, enhanced/cleaned/arranged structure
24  *   3       2007-11-15 RAW DDL data type added; some inconsistencies fixed
25  *           ('void' and 'any' origins); added signed HLT basic data types
26  *           2007-11-23 origin defines have become variables in conjunction
27  *           to be used with the operator| (AliHLTComponentDataType)
28  *           2007-11-24 added trigger structs and ESD tree data type
29  */
30 #define ALIHLT_DATA_TYPES_VERSION 3
31
32 //////////////////////////////////////////////////////////////////////////
33 //
34 // HLT data origin variables.
35 //
36 // By converting from defines to variables, the origins can be used with
37 // the operator|
38 //
39 // AliHLTComponentDataType dt;
40 // dt = kAliHLTDataTypeDDLRaw | gkAliHLTDataOriginTPC;
41 //
42 //////////////////////////////////////////////////////////////////////////
43
44 /** field size of datat type origin */
45 const int kAliHLTComponentDataTypefOriginSize=4;
46
47
48 /** invalid data origin */
49 # define kAliHLTDataOriginVoid "\0\0\0"
50 /** old invalid data origin, kept for backward compatibility */
51 # define kAliHLTVoidDataOrigin "\0\0\0"
52
53 /** wildcard data type origin */
54 # define kAliHLTDataOriginAny "***"
55 /** old wildcard data type origin, kept for backward compatibility */
56 # define kAliHLTAnyDataOrigin "***"
57
58 /** HLT out */
59 extern const char kAliHLTDataOriginOut[kAliHLTComponentDataTypefOriginSize];
60
61 /** HLT/PubSub private internal */
62 extern const char kAliHLTDataOriginPrivate[kAliHLTComponentDataTypefOriginSize];
63
64 /** TPC */
65 extern const char kAliHLTDataOriginTPC[kAliHLTComponentDataTypefOriginSize];
66
67 /** PHOS */
68 extern const char kAliHLTDataOriginPHOS[kAliHLTComponentDataTypefOriginSize];
69
70 /** MUON */
71 extern const char kAliHLTDataOriginMUON[kAliHLTComponentDataTypefOriginSize];
72
73 /** TRD */
74 extern const char kAliHLTDataOriginTRD[kAliHLTComponentDataTypefOriginSize];
75
76 /** ITS */
77 extern const char kAliHLTDataOriginITS[kAliHLTComponentDataTypefOriginSize];
78
79 //////////////////////////////////////////////////////////////////////////
80 //
81 // HLT common data type defines
82 //
83 //////////////////////////////////////////////////////////////////////////
84
85 /** field size of data type id */
86 const int kAliHLTComponentDataTypefIDsize=8;
87
88
89 /** invalid data type id */
90 # define kAliHLTVoidDataTypeID "\0\0\0\0\0\0\0"
91
92 /** special id for any data type id */
93 # define kAliHLTAnyDataTypeID "*******"
94
95 /** DDL RAW data */
96 # define kAliHLTDDLRawDataTypeID   {'D','D','L','_','R','A','W',' '}
97
98 /** calibration data for file exchange subscriber */
99 # define kAliHLTFXSCalibDataTypeID {'F','X','S','_','C','A','L',' '}
100
101 /** start of run (SOR) event 
102  * @ref AliHLTRunDesc
103  */
104 # define kAliHLTSORDataTypeID      {'S','T','A','R','T','O','F','R'}
105
106 /** end of run (EOR) event 
107  * @ref AliHLTRunDesc
108  */
109 # define kAliHLTEORDataTypeID      {'E','N','D','O','F','R','U','N'}
110
111 /** DDL list event 
112  * @ref AliHLTEventDDL
113  */
114 # define kAliHLTDDLDataTypeID      {'D','D','L','L','I','S','T',' '}
115
116 /** EventType event 
117  * - empty payload, specification gives eventType
118  */
119 # define kAliHLTEventDataTypeID    {'E','V','E','N','T','T','Y','P'}
120
121 /** ESD data block
122  * an AliESD object of varying origin
123  */
124 # define kAliHLTESDTreeDataTypeID      {'E','S','D','_','T','R','E','E'}
125
126 using namespace std;
127
128 extern "C" {
129   //////////////////////////////////////////////////////////////////////////
130   //
131   // Basic HLT data types
132   //
133   //////////////////////////////////////////////////////////////////////////
134
135   typedef unsigned char AliHLTUInt8_t;
136
137   typedef signed char AliHLTInt8_t;
138
139   typedef unsigned short AliHLTUInt16_t;
140
141   typedef signed short AliHLTInt16_t;
142
143   typedef unsigned int AliHLTUInt32_t;
144
145   typedef signed int AliHLTInt32_t;
146
147   typedef unsigned long long AliHLTUInt64_t;
148
149   typedef signed long long AliHLTInt64_t;
150
151   typedef float AliHLTFloat32_t;
152
153   typedef double AliHLTFloat64_t;
154
155   typedef AliHLTUInt64_t AliHLTEventID_t;
156
157   //////////////////////////////////////////////////////////////////////////
158   //
159   // HLT logging levels
160   //
161   //////////////////////////////////////////////////////////////////////////
162
163   enum AliHLTComponentLogSeverity { 
164     kHLTLogNone      = 0,
165     kHLTLogBenchmark = 0x1,
166     kHLTLogDebug     = 0x2,
167     kHLTLogInfo      = 0x4,
168     kHLTLogWarning   = 0x8,
169     kHLTLogError     = 0x10,
170     kHLTLogFatal     = 0x20,
171     kHLTLogAll       = 0x3f,
172     kHLTLogDefault   = 0x3d 
173 };
174
175   //////////////////////////////////////////////////////////////////////////
176   //
177   // HLT data structures for data exchange and external interface
178   //
179   //////////////////////////////////////////////////////////////////////////
180
181   /**
182    * @struct AliHLTComponentEventData
183    * Event descriptor
184    */
185   struct AliHLTComponentEventData
186   {
187     AliHLTUInt32_t fStructSize;
188     AliHLTEventID_t fEventID;
189     AliHLTUInt32_t fEventCreation_s;
190     AliHLTUInt32_t fEventCreation_us;
191     AliHLTUInt32_t fBlockCnt;
192   };
193
194   /**
195    * @struct AliHLTComponentShmData
196    * Shared memory descriptor.
197    * Irrelevant for analysis components.
198    */
199   struct AliHLTComponentShmData
200   {
201     AliHLTUInt32_t fStructSize;
202     AliHLTUInt32_t fShmType;
203     AliHLTUInt64_t fShmID;
204   };
205
206   /**
207    * @struct AliHLTComponentDataType
208    * Data type descriptor for data blocks transferred through the processing
209    * chain.
210    */
211   struct AliHLTComponentDataType
212   {
213     AliHLTUInt32_t fStructSize;
214     char fID[kAliHLTComponentDataTypefIDsize];                      //!
215     char fOrigin[kAliHLTComponentDataTypefOriginSize];              //!
216   };
217
218   /**
219    * @struct AliHLTComponentBlockData
220    * This is the decription of data blocks exchanged between components.
221    * \b IMPORTANT: The validity of fPtr and fOffset is different for input and
222    * output blocks:
223    * - input blocks: The \em fPtr member always points to the beginning of the data
224    *                 of size \em fSize. fOffset is ignored and should be in most
225    *                 case 0.
226    * - output blocks: The \em fPtr member is ignored by the framework. \em fOffset
227    *                  must specify the start of the data relative to the output
228    *                  buffer. The data block has size \em fSize.
229    */
230   struct AliHLTComponentBlockData
231   {
232     /* size and version of the struct */
233     AliHLTUInt32_t fStructSize;
234     /* shared memory key, ignored by processing components */
235     AliHLTComponentShmData fShmKey;
236     /* offset of output data relative to the output buffer */
237     AliHLTUInt32_t fOffset;
238     /* start of the data for input data blocks, fOffset to be ignored*/
239     void* fPtr;
240     /* size of the data block */
241     AliHLTUInt32_t fSize;
242     /* data type of the data block */
243     AliHLTComponentDataType fDataType;
244     /* data specification of the data block */
245     AliHLTUInt32_t fSpecification;
246   };
247
248   /**
249    * @struct AliHLTComponentEventDoneData
250    * 
251    */
252   struct AliHLTComponentEventDoneData
253   {
254     AliHLTUInt32_t fStructSize;
255     AliHLTUInt32_t fDataSize;
256     void* fData;
257   };
258
259   /**
260    * @struct AliHLTRunDesc
261    * Event descriptor.
262    * The struct is send with the SOR and EOR events.
263    */
264   struct AliHLTRunDesc
265   {
266     AliHLTUInt32_t fStructSize;
267     AliHLTUInt32_t fRunNo;
268     AliHLTUInt32_t fRunType;
269   };
270
271   //////////////////////////////////////////////////////////////////////////
272   //
273   // Trigger meta information
274   //
275   //////////////////////////////////////////////////////////////////////////
276
277   /** field size of fAttribute */
278   static const int gkAliHLTBlockDAttributeCount = 8;
279
280   /** field size of fCommonHeader */
281   static const int gkAliHLTCommonHeaderCount = 8;
282
283   /** size of the DDL list */
284   static const int gkAliHLTDDLListSize = 29;
285
286   /**
287    * @struct AliHLTEventDDL
288    * DDL list event.
289    * The struct is send with the DDLLIST event.
290    * Used in the trigger structure for internal apperance of 
291    * the DLLs as well as for the HLT readout list send to DAQ 
292    * ( as DataType :kAliHLTDataTypeDDL  )
293    */
294   struct AliHLTEventDDL
295   {
296     AliHLTUInt32_t fCount;
297     AliHLTUInt32_t fList[gkAliHLTDDLListSize];
298   };
299
300   /**
301    * @struct AliHLTBlockHeader
302    * 1 to 1 copy from HLT framework, remember before changeing
303    */
304   struct AliHLTBlockHeader
305   {
306     AliHLTUInt32_t fLength;
307     union 
308     {
309       AliHLTUInt32_t      fID;
310       AliHLTUInt8_t       fDescr[4];
311     } fType;
312     union 
313     {
314       AliHLTUInt32_t      fID:24;
315       AliHLTUInt8_t       fDescr[3];
316     } fSubType;
317     AliHLTUInt8_t fVersion;
318   };
319   
320   /**
321    * @struct AliHLTEventTriggerStruct
322    * 1 to 1 copy from HLT framework, remember before changeing
323    */
324   struct AliHLTEventTriggerStruct
325   {
326     AliHLTBlockHeader fHeader;
327     AliHLTUInt32_t fDataWordCount;
328     AliHLTUInt32_t fDataWords[0];
329   };
330
331   /**
332    * @struct AliHLTEventTriggerData
333    * 1 to 1 copy from HLT framework, remember before changeing
334    */
335   struct AliHLTEventTriggerData
336   {
337     AliHLTEventTriggerStruct fETS;
338     AliHLTUInt8_t  fAttributes[gkAliHLTBlockDAttributeCount]; 
339     /** Bit field */
340     AliHLTUInt64_t fHLTStatus; 
341     AliHLTUInt32_t fCommonHeaderWordCnt;
342     AliHLTUInt32_t fCommonHeader[gkAliHLTCommonHeaderCount]; 
343     /** First word holds number of words (excluding first word) */
344     //AliHLTUInt32_t fReadoutList[gkAliHLTDDLListSize+1];  
345     AliHLTEventDDL fReadoutList;
346   };
347
348   /**
349    * @struct AliHLTComponentTriggerData
350    * Trigger data
351    */
352   struct AliHLTComponentTriggerData
353   {
354     AliHLTUInt32_t fStructSize;
355     AliHLTUInt32_t fDataSize;
356     void* fData;
357   };
358
359   //////////////////////////////////////////////////////////////////////////
360   //
361   // HLT Event Type Specification
362   //
363   //////////////////////////////////////////////////////////////////////////
364
365   /** Unknown eventType specification */
366   static const AliHLTUInt32_t gkAliEventTypeUnknown = ~(AliHLTUInt32_t)0;
367   /** SOR eventType specification */ 
368   static const AliHLTUInt32_t gkAliEventTypeStartOfRun=1;
369   /** Data eventType specification */
370   static const AliHLTUInt32_t gkAliEventTypeData=2;
371   /** EOR eventType specification */ 
372   static const AliHLTUInt32_t gkAliEventTypeEndOfRun=4;
373   /** Corrupt eventType specification */
374   static const AliHLTUInt32_t gkAliEventTypeCorruptID=8;
375   /** Calibration eventType specification */ 
376   static const AliHLTUInt32_t gkAliEventTypeCalibration=16;
377   /** DataReplay eventType specification */
378   static const AliHLTUInt32_t gkAliEventTypeDataReplay=32;
379   /** Tick eventType specification */ 
380   static const AliHLTUInt32_t gkAliEventTypeTick=64;
381   /** Max eventType specification */ 
382   static const AliHLTUInt32_t gkAliEventTypeMax=64;
383
384   //////////////////////////////////////////////////////////////////////////
385   //
386   // HLT defines and defaults
387   //
388   //////////////////////////////////////////////////////////////////////////
389
390   /** invalid event id */
391   const AliHLTEventID_t kAliHLTVoidEventID=~(AliHLTEventID_t)0;
392
393   /** invalid data specification */
394   const AliHLTUInt32_t kAliHLTVoidDataSpec = ~(AliHLTUInt32_t)0;
395
396   /** invalid shared memory type */
397   const AliHLTUInt32_t gkAliHLTComponentInvalidShmType = 0;
398
399   /** invalid shared memory id */
400   const AliHLTUInt64_t gkAliHLTComponentInvalidShmID = ~(AliHLTUInt64_t)0;
401
402   /** invalid data type */
403   const AliHLTComponentDataType kAliHLTVoidDataType = {
404     sizeof(AliHLTComponentDataType),
405     kAliHLTVoidDataTypeID,
406     kAliHLTDataOriginVoid
407   };
408
409   // there is currently a problem with rootcint if the predefined ids
410   // (commented below) are used. rootcint does not find the id if they
411   // are char arrays defined with {} and individual chars. If strings
412   // are used it works fine
413   /** any data type */
414   const AliHLTComponentDataType kAliHLTAnyDataType = {
415     sizeof(AliHLTComponentDataType),
416     kAliHLTAnyDataTypeID,
417     kAliHLTDataOriginAny
418   };
419
420   /** multiple output data types */
421   extern const AliHLTComponentDataType kAliHLTMultipleDataType;
422
423   /** data to file exchange subscriber */
424   extern const AliHLTComponentDataType kAliHLTDataTypeFXSCalib;
425
426   /** DDL list data type */
427   extern const AliHLTComponentDataType kAliHLTDataTypeDDL;
428
429   /** SOR data type */
430   extern const AliHLTComponentDataType kAliHLTDataTypeSOR;
431
432   /** EOR data type */
433   extern const AliHLTComponentDataType kAliHLTDataTypeEOR;
434
435   /** Event type specification */
436   extern const AliHLTComponentDataType kAliHLTDataTypeEvent;
437
438   /** RAW DDL data specification, origin is 'any', data publisher origin correctly */
439   extern const AliHLTComponentDataType kAliHLTDataTypeDDLRaw;
440
441   /** ESD Tree data specification, origin is 'any' */
442   extern const AliHLTComponentDataType kAliHLTDataTypeESDTree;
443
444   //////////////////////////////////////////////////////////////////////////
445   //
446   // FXS subscriber meta information
447   //
448   //////////////////////////////////////////////////////////////////////////
449
450   static const int gkAliHLTFXSHeaderfOriginSize = 4;
451   static const int gkAliHLTFXSHeaderfFileIDSize = 128;
452   static const int gkAliHLTFXSHeaderfDDLNumberSize = 64;
453
454   /** Header in front of the data payload, in order to sent data to the FXS. */
455   struct AliHLTFXSHeader
456   {
457     AliHLTUInt32_t fHeaderVersion;
458     AliHLTUInt32_t fRunNumber;
459     char fOrigin[gkAliHLTFXSHeaderfOriginSize];
460     char fFileID[gkAliHLTFXSHeaderfFileIDSize];
461     char fDDLNumber[gkAliHLTFXSHeaderfDDLNumberSize];
462   };  
463
464   //////////////////////////////////////////////////////////////////////////
465   //
466   // Component running environment
467   //
468   //////////////////////////////////////////////////////////////////////////
469
470   /** logging function */
471   typedef int (*AliHLTfctLogging)( void* param, 
472                                    AliHLTComponentLogSeverity severity,
473                                    const char* origin,
474                                    const char* keyword,
475                                    const char* message);
476
477   /**
478    * @struct AliHLTComponentEnvironment
479    * Running environment for analysis components.
480    * The struct describes function callbacks for 
481    */
482   struct AliHLTComponentEnvironment
483   {
484     AliHLTUInt32_t fStructSize;
485     void* fParam;
486     void* (*fAllocMemoryFunc)( void* param, unsigned long size );
487 #if 0
488     // future addition already foreseen/envisioned
489     // IMPORTANT: don not just remove the defines as this breaks the binary
490     // compatibility
491     int (*fAllocShmMemoryFunc)( void* param, unsigned long size, AliHLTComponentBlockData* blockLocation );
492 #endif
493     int (*fGetEventDoneDataFunc)( void* param, AliHLTEventID_t eventID, unsigned long size, AliHLTComponentEventDoneData** edd );
494     AliHLTfctLogging fLoggingFunc;
495   };
496 }
497
498 //////////////////////////////////////////////////////////////////////////
499 //
500 // Data type helper functions
501 //
502 //////////////////////////////////////////////////////////////////////////
503
504 inline bool operator==( const AliHLTComponentDataType& dt1, const AliHLTComponentDataType& dt2 )
505     {
506     for ( int i = 0; i < kAliHLTComponentDataTypefIDsize; i++ )
507         if ( dt1.fID[i] != dt2.fID[i] )
508             return false;
509     for ( int i = 0; i < kAliHLTComponentDataTypefOriginSize; i++ )
510         if ( dt1.fOrigin[i] != dt2.fOrigin[i] )
511             return false;
512     return true;
513     }
514
515 inline bool operator!=( const AliHLTComponentDataType& dt1, const AliHLTComponentDataType& dt2 )
516     {
517     for ( int i = 0; i < kAliHLTComponentDataTypefIDsize; i++ )
518         if ( dt1.fID[i] != dt2.fID[i] )
519             return true;
520     for ( int i = 0; i < kAliHLTComponentDataTypefOriginSize; i++ )
521         if ( dt1.fOrigin[i] != dt2.fOrigin[i] )
522             return true;
523     return false;
524     }
525
526 inline AliHLTComponentDataType operator|(const AliHLTComponentDataType srcdt, const char origin[kAliHLTComponentDataTypefOriginSize])
527     {
528     AliHLTComponentDataType dt=srcdt;
529     for ( int i = 0; i < kAliHLTComponentDataTypefOriginSize; i++ )
530       dt.fOrigin[i]=origin[i];
531     return dt;
532     }
533
534 #endif