]>
Commit | Line | Data |
---|---|---|
f23a6e1a | 1 | // @(#) $Id$ |
2 | ||
3 | #ifndef ALIHLTDATATYPES_H | |
4 | #define ALIHLTDATATYPES_H | |
32db4144 | 5 | /* This file is property of and copyright by the ALICE HLT Project * |
6 | * ALICE Experiment at CERN, All rights reserved. * | |
f23a6e1a | 7 | * See cxx source for full Copyright notice */ |
8 | ||
b22e91eb | 9 | /** @file AliHLTDataTypes.h |
32db4144 | 10 | @author Matthias Richter, Timm Steinbeck, Jochen Thaeder |
b22e91eb | 11 | @date |
12 | @brief Data type declaration for the HLT module. | |
13 | */ | |
14 | ||
2cbdb37e | 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 | |
eda89fe6 | 24 | * 3 2007-11-15 RAW DDL data type added; some inconsistencies fixed |
25 | * ('void' and 'any' origins); added signed HLT basic data types | |
69347e0d | 26 | * 2007-11-23 origin defines have become variables in conjunction |
c704e290 | 27 | * to be used with the operator| (AliHLTComponentDataType) |
28 | * 2007-11-24 added trigger structs and ESD tree data type | |
b543e186 | 29 | * 4 Component configuration and DCS update events added |
2efb85be | 30 | * gkAliHLTDDLListSize set from 29 to 30 according to new PubSub |
31 | * specs | |
c736de25 | 32 | * 5 Data types for Run and Event summary, and for monitoring added |
1ac82ce6 | 33 | * 6 Common data types for TreeD and TreeR defined |
703bcca6 | 34 | * kAliHLTAllDataTypes and kAliHLTDataOriginSample added |
d9dd3bc8 | 35 | * kAliHLTDataOriginEMCAL added |
45c0a780 | 36 | * kAliHLTDataTypeRunType added |
a0aeb701 | 37 | * 7 kAliHLTDataTypeComponentStatistics, kAliHLTDataTypeComponentTable, |
38 | * and AliHLTComponentStatistics have been added for optional | |
39 | * component block statistics | |
2cbdb37e | 40 | */ |
a0aeb701 | 41 | #define ALIHLT_DATA_TYPES_VERSION 7 |
2cbdb37e | 42 | |
32db4144 | 43 | ////////////////////////////////////////////////////////////////////////// |
44 | // | |
69347e0d | 45 | // HLT data origin variables. |
46 | // | |
47 | // By converting from defines to variables, the origins can be used with | |
48 | // the operator| | |
49 | // | |
50 | // AliHLTComponentDataType dt; | |
51 | // dt = kAliHLTDataTypeDDLRaw | gkAliHLTDataOriginTPC; | |
32db4144 | 52 | // |
53 | ////////////////////////////////////////////////////////////////////////// | |
54 | ||
1ac82ce6 | 55 | /** field size of datat type origin |
56 | * @ingroup alihlt_component_datatypes | |
57 | */ | |
32db4144 | 58 | const int kAliHLTComponentDataTypefOriginSize=4; |
59 | ||
60 | ||
1ac82ce6 | 61 | /** invalid data origin |
62 | * @ingroup alihlt_component_datatypes | |
63 | */ | |
3f850585 | 64 | # define kAliHLTDataOriginVoid "\0\0\0" |
65 | /** old invalid data origin, kept for backward compatibility */ | |
32db4144 | 66 | # define kAliHLTVoidDataOrigin "\0\0\0" |
67 | ||
1ac82ce6 | 68 | /** wildcard data type origin |
69 | * @ingroup alihlt_component_datatypes | |
70 | */ | |
3f850585 | 71 | # define kAliHLTDataOriginAny "***" |
72 | /** old wildcard data type origin, kept for backward compatibility */ | |
32db4144 | 73 | # define kAliHLTAnyDataOrigin "***" |
74 | ||
1ac82ce6 | 75 | /** Data origin HLT out |
76 | * @ingroup alihlt_component_datatypes | |
77 | */ | |
69347e0d | 78 | extern const char kAliHLTDataOriginOut[kAliHLTComponentDataTypefOriginSize]; |
32db4144 | 79 | |
1ac82ce6 | 80 | /** Data origin HLT/PubSub private internal |
81 | * @ingroup alihlt_component_datatypes | |
82 | */ | |
69347e0d | 83 | extern const char kAliHLTDataOriginPrivate[kAliHLTComponentDataTypefOriginSize]; |
32db4144 | 84 | |
1ac82ce6 | 85 | /** Data origin TPC |
86 | * @ingroup alihlt_component_datatypes | |
87 | */ | |
69347e0d | 88 | extern const char kAliHLTDataOriginTPC[kAliHLTComponentDataTypefOriginSize]; |
32db4144 | 89 | |
1ac82ce6 | 90 | /** Data origin PHOS |
91 | * @ingroup alihlt_component_datatypes | |
92 | */ | |
69347e0d | 93 | extern const char kAliHLTDataOriginPHOS[kAliHLTComponentDataTypefOriginSize]; |
32db4144 | 94 | |
1ac82ce6 | 95 | /** Data origin MUON |
96 | * @ingroup alihlt_component_datatypes | |
97 | */ | |
69347e0d | 98 | extern const char kAliHLTDataOriginMUON[kAliHLTComponentDataTypefOriginSize]; |
32db4144 | 99 | |
1ac82ce6 | 100 | /** Data origin TRD |
101 | * @ingroup alihlt_component_datatypes | |
102 | */ | |
69347e0d | 103 | extern const char kAliHLTDataOriginTRD[kAliHLTComponentDataTypefOriginSize]; |
32db4144 | 104 | |
1ac82ce6 | 105 | /** Data origin ITS |
106 | * @ingroup alihlt_component_datatypes | |
107 | */ | |
69347e0d | 108 | extern const char kAliHLTDataOriginITS[kAliHLTComponentDataTypefOriginSize]; |
32db4144 | 109 | |
703bcca6 | 110 | /** Data origin for examples |
111 | * @ingroup alihlt_component_datatypes | |
112 | */ | |
113 | extern const char kAliHLTDataOriginSample[kAliHLTComponentDataTypefOriginSize]; | |
114 | ||
d9dd3bc8 | 115 | /** Data origin EMCAL |
116 | * @ingroup alihlt_component_datatypes | |
117 | */ | |
118 | extern const char kAliHLTDataOriginEMCAL[kAliHLTComponentDataTypefOriginSize]; | |
119 | ||
32db4144 | 120 | ////////////////////////////////////////////////////////////////////////// |
121 | // | |
122 | // HLT common data type defines | |
123 | // | |
124 | ////////////////////////////////////////////////////////////////////////// | |
125 | ||
1ac82ce6 | 126 | /** field size of data type id |
127 | * @ingroup alihlt_component_datatypes | |
128 | */ | |
32db4144 | 129 | const int kAliHLTComponentDataTypefIDsize=8; |
130 | ||
131 | ||
1ac82ce6 | 132 | /** invalid data type id |
133 | * @ingroup alihlt_component_datatypes | |
134 | */ | |
32db4144 | 135 | # define kAliHLTVoidDataTypeID "\0\0\0\0\0\0\0" |
136 | ||
3dd8541e | 137 | /** special id for all data types: any + void |
138 | * @ingroup alihlt_component_datatypes | |
139 | */ | |
140 | # define kAliHLTAllDataTypesID "ALLDATA" | |
141 | ||
142 | /** special id for any valid data type id | |
1ac82ce6 | 143 | * @ingroup alihlt_component_datatypes |
144 | */ | |
32db4144 | 145 | # define kAliHLTAnyDataTypeID "*******" |
146 | ||
1ac82ce6 | 147 | /** DDL RAW data |
148 | * @ingroup alihlt_component_datatypes | |
149 | */ | |
3f850585 | 150 | # define kAliHLTDDLRawDataTypeID {'D','D','L','_','R','A','W',' '} |
151 | ||
1ac82ce6 | 152 | /** calibration data for file exchange subscriber |
153 | * @ingroup alihlt_component_datatypes | |
154 | */ | |
32db4144 | 155 | # define kAliHLTFXSCalibDataTypeID {'F','X','S','_','C','A','L',' '} |
156 | ||
157 | /** start of run (SOR) event | |
2cbdb37e | 158 | * @ref AliHLTRunDesc |
1ac82ce6 | 159 | * @ingroup alihlt_component_datatypes |
32db4144 | 160 | */ |
161 | # define kAliHLTSORDataTypeID {'S','T','A','R','T','O','F','R'} | |
162 | ||
163 | /** end of run (EOR) event | |
2cbdb37e | 164 | * @ref AliHLTRunDesc |
1ac82ce6 | 165 | * @ingroup alihlt_component_datatypes |
32db4144 | 166 | */ |
167 | # define kAliHLTEORDataTypeID {'E','N','D','O','F','R','U','N'} | |
168 | ||
45c0a780 | 169 | /** run type data block |
170 | * string with run type as payload | |
171 | * @ingroup alihlt_component_datatypes | |
172 | */ | |
173 | # define kAliHLTRunTypeDataTypeID {'R','U','N','T','Y','P','E',' '} | |
174 | ||
32db4144 | 175 | /** DDL list event |
176 | * @ref AliHLTEventDDL | |
1ac82ce6 | 177 | * @ingroup alihlt_component_datatypes |
32db4144 | 178 | */ |
179 | # define kAliHLTDDLDataTypeID {'D','D','L','L','I','S','T',' '} | |
180 | ||
9d9ffd37 | 181 | /** EventType event |
182 | * - empty payload, specification gives eventType | |
1ac82ce6 | 183 | * @ingroup alihlt_component_datatypes |
9d9ffd37 | 184 | */ |
185 | # define kAliHLTEventDataTypeID {'E','V','E','N','T','T','Y','P'} | |
186 | ||
853121af | 187 | /** ComponentConfiguration event |
b543e186 | 188 | * - payload contains the CDB path as string |
1ac82ce6 | 189 | * @ingroup alihlt_component_datatypes |
853121af | 190 | */ |
191 | # define kAliHLTComConfDataTypeID {'C','O','M','_','C','O','N','F'} | |
192 | ||
b543e186 | 193 | /** DCS value update event |
194 | * - payload contains string of relevant detectors | |
1ac82ce6 | 195 | * @ingroup alihlt_component_datatypes |
b543e186 | 196 | */ |
197 | # define kAliHLTUpdtDCSDataTypeID {'U','P','D','T','_','D','C','S'} | |
198 | ||
c704e290 | 199 | /** ESD data block |
200 | * an AliESD object of varying origin | |
853121af | 201 | * The 'V0' at the end allows a versioning |
1ac82ce6 | 202 | * @ingroup alihlt_component_datatypes |
c704e290 | 203 | */ |
a978c0d5 | 204 | # define kAliHLTESDObjectDataTypeID {'A','L','I','E','S','D','V','0'} |
c704e290 | 205 | |
a978c0d5 | 206 | /** ESD tree data block |
207 | * TTree with an AliESD object of varying origin | |
1ac82ce6 | 208 | * @ingroup alihlt_component_datatypes |
a978c0d5 | 209 | */ |
210 | # define kAliHLTESDTreeDataTypeID {'E','S','D','_','T','R','E','E'} | |
64defa03 | 211 | |
1ac82ce6 | 212 | /** AliRoot TreeD |
213 | * - the digits tree of an AliRoot module | |
214 | * @ingroup alihlt_component_datatypes | |
215 | */ | |
216 | #define kAliHLTTreeDDataTypeID {'A','L','I','T','R','E','E','D'} | |
217 | ||
218 | /** AliRoot TreeR | |
219 | * - the rec points tree of an AliRoot module | |
220 | * @ingroup alihlt_component_datatypes | |
221 | */ | |
222 | #define kAliHLTTreeRDataTypeID {'A','L','I','T','R','E','E','D'} | |
223 | ||
64defa03 | 224 | /** HW Address selection data block |
225 | * - a selection list for 16 bit HW addresses | |
226 | * - varying origin | |
1ac82ce6 | 227 | * @ingroup alihlt_component_datatypes |
64defa03 | 228 | */ |
229 | # define kAliHLTHwAddr16DataTypeID {'H','W','A','D','D','R','1','6'} | |
230 | ||
2ff24e4c | 231 | /** Event Statistics |
232 | * - event statistics for given detectors | |
233 | * - varying origin | |
1ac82ce6 | 234 | * @ingroup alihlt_component_datatypes |
2ff24e4c | 235 | */ |
236 | # define kAliHLTEventStatisticsDataTypeID {'E','V','_','S','T','A','T','I'} | |
237 | ||
238 | /** Event Summary | |
239 | * - event summary | |
240 | * - origin : kAliHLTDataOriginOut ( HLT ) | |
1ac82ce6 | 241 | * @ingroup alihlt_component_datatypes |
2ff24e4c | 242 | */ |
243 | # define kAliHLTEventSummaryDataTypeID {'E','V','_','S','U','M','M','A'} | |
244 | ||
245 | /** Run Statistics | |
246 | * - run statistics for given detectors | |
247 | * - varying origin | |
1ac82ce6 | 248 | * @ingroup alihlt_component_datatypes |
2ff24e4c | 249 | */ |
250 | # define kAliHLTRunStatisticsDataTypeID {'R','U','N','S','T','A','T','I'} | |
251 | ||
252 | /** Run Summary | |
253 | * - run summary | |
254 | * - origin : kAliHLTDataOriginOut ( HLT ) | |
1ac82ce6 | 255 | * @ingroup alihlt_component_datatypes |
2ff24e4c | 256 | */ |
257 | # define kAliHLTRunSummaryDataTypeID {'R','U','N','S','U','M','M','A'} | |
258 | ||
a0aeb701 | 259 | /** Block Statistics |
260 | * - small block statistics info added to the data stream by | |
261 | * the component base class | |
262 | * - origin kAliHLTDataOriginPrivate | |
263 | * @ingroup alihlt_component_datatypes | |
264 | */ | |
265 | # define kAliHLTComponentStatisticsDataTypeID {'C','O','M','P','S','T','A','T'} | |
266 | ||
267 | /** Component table | |
268 | * - list of components in the chain to be percolated through the chain | |
269 | * - each component adds it's chain id string and a generated 32bit id | |
270 | * @ingroup alihlt_component_datatypes | |
271 | */ | |
272 | # define kAliHLTComponentTableDataTypeID {'C','O','M','P','T','A','B','L'} | |
273 | ||
c736de25 | 274 | /** general ROOT TObject |
275 | * - a general TObject exported from the HLT analysis | |
276 | * - varying origin | |
1ac82ce6 | 277 | * @ingroup alihlt_component_datatypes |
c736de25 | 278 | */ |
279 | #define kAliHLTTObjectDataTypeID {'R','O','O','T','T','O','B','J'} | |
280 | ||
281 | /** ROOT TObjArray | |
282 | * - a TObjArray exported from the HLT analysis | |
283 | * - varying origin | |
1ac82ce6 | 284 | * @ingroup alihlt_component_datatypes |
c736de25 | 285 | */ |
286 | #define kAliHLTTObjArrayDataTypeID {'R','O','O','T','O','B','A','R'} | |
287 | ||
288 | /** ROOT TTree | |
289 | * - a TTree object exported from the HLT analysis | |
290 | * - varying origin | |
1ac82ce6 | 291 | * @ingroup alihlt_component_datatypes |
c736de25 | 292 | */ |
293 | #define kAliHLTTTreeDataTypeID {'R','O','O','T','T','R','E','E'} | |
294 | ||
295 | /** ROOT histogram | |
296 | * - a histogram object exported from the HLT analysis | |
297 | * - class derives from TH1 (directly or indirectly) and inherits all common functionality | |
298 | * - varying origin | |
1ac82ce6 | 299 | * @ingroup alihlt_component_datatypes |
c736de25 | 300 | */ |
301 | #define kAliHLTHistogramDataTypeID {'R','O','O','T','H','I','S','T'} | |
302 | ||
303 | /** ROOT TNtuple | |
304 | * - a TNtupl object exported from the HLT analysis | |
305 | * - varying origin | |
1ac82ce6 | 306 | * @ingroup alihlt_component_datatypes |
c736de25 | 307 | */ |
308 | #define kAliHLTTNtupleDataTypeID {'R','O','O','T','T','U','P','L'} | |
309 | ||
1843b457 | 310 | using namespace std; |
f23a6e1a | 311 | |
312 | extern "C" { | |
32db4144 | 313 | ////////////////////////////////////////////////////////////////////////// |
314 | // | |
315 | // Basic HLT data types | |
316 | // | |
317 | ////////////////////////////////////////////////////////////////////////// | |
f23a6e1a | 318 | |
319 | typedef unsigned char AliHLTUInt8_t; | |
320 | ||
eda89fe6 | 321 | typedef signed char AliHLTInt8_t; |
322 | ||
71d7c760 | 323 | typedef unsigned short AliHLTUInt16_t; |
324 | ||
eda89fe6 | 325 | typedef signed short AliHLTInt16_t; |
326 | ||
f23a6e1a | 327 | typedef unsigned int AliHLTUInt32_t; |
328 | ||
eda89fe6 | 329 | typedef signed int AliHLTInt32_t; |
330 | ||
f23a6e1a | 331 | typedef unsigned long long AliHLTUInt64_t; |
332 | ||
eda89fe6 | 333 | typedef signed long long AliHLTInt64_t; |
334 | ||
335 | typedef float AliHLTFloat32_t; | |
336 | ||
337 | typedef double AliHLTFloat64_t; | |
338 | ||
f23a6e1a | 339 | typedef AliHLTUInt64_t AliHLTEventID_t; |
340 | ||
32db4144 | 341 | ////////////////////////////////////////////////////////////////////////// |
342 | // | |
343 | // HLT logging levels | |
344 | // | |
345 | ////////////////////////////////////////////////////////////////////////// | |
f23a6e1a | 346 | |
2efb85be | 347 | /** |
348 | * Logging severities of the HLT | |
349 | */ | |
350 | enum AliHLTComponentLogSeverity { | |
351 | /** no logging */ | |
32db4144 | 352 | kHLTLogNone = 0, |
2efb85be | 353 | /** benchmark messages */ |
32db4144 | 354 | kHLTLogBenchmark = 0x1, |
2efb85be | 355 | /** debug messages */ |
32db4144 | 356 | kHLTLogDebug = 0x2, |
2efb85be | 357 | /** info messages */ |
32db4144 | 358 | kHLTLogInfo = 0x4, |
2efb85be | 359 | /** warning messages */ |
32db4144 | 360 | kHLTLogWarning = 0x8, |
2efb85be | 361 | /** error messages */ |
32db4144 | 362 | kHLTLogError = 0x10, |
b2065764 | 363 | /** fatal error messages */ |
32db4144 | 364 | kHLTLogFatal = 0x20, |
b2065764 | 365 | /** few important messages not to be filtered out. |
366 | * redirected to kHLTLogInfo in AliRoot | |
367 | */ | |
368 | kHLTLogImportant = 0x40, | |
2efb85be | 369 | /** special value to enable all messages */ |
b2065764 | 370 | kHLTLogAll = 0x7f, |
2efb85be | 371 | /** the default logging filter */ |
7233bc62 | 372 | kHLTLogDefault = 0x79 |
32db4144 | 373 | }; |
374 | ||
375 | ////////////////////////////////////////////////////////////////////////// | |
376 | // | |
377 | // HLT data structures for data exchange and external interface | |
378 | // | |
379 | ////////////////////////////////////////////////////////////////////////// | |
380 | ||
381 | /** | |
382 | * @struct AliHLTComponentEventData | |
383 | * Event descriptor | |
384 | */ | |
8ede8717 | 385 | struct AliHLTComponentEventData |
f23a6e1a | 386 | { |
387 | AliHLTUInt32_t fStructSize; | |
388 | AliHLTEventID_t fEventID; | |
389 | AliHLTUInt32_t fEventCreation_s; | |
390 | AliHLTUInt32_t fEventCreation_us; | |
391 | AliHLTUInt32_t fBlockCnt; | |
392 | }; | |
393 | ||
32db4144 | 394 | /** |
395 | * @struct AliHLTComponentShmData | |
396 | * Shared memory descriptor. | |
397 | * Irrelevant for analysis components. | |
398 | */ | |
8ede8717 | 399 | struct AliHLTComponentShmData |
f23a6e1a | 400 | { |
401 | AliHLTUInt32_t fStructSize; | |
402 | AliHLTUInt32_t fShmType; | |
403 | AliHLTUInt64_t fShmID; | |
404 | }; | |
71d7c760 | 405 | |
1ac82ce6 | 406 | /** |
407 | * @defgroup alihlt_component_datatypes Common Component Data Types | |
408 | * The analysis framework defines a number of common data types for | |
409 | * usage in the detector modules, like e.g. ::kAliHLTAnyDataType | |
410 | * and ::kAliHLTDataTypeDDLRaw. Those data types always have | |
411 | * origin ::kAliHLTDataOriginAny. The correct detector origin can be | |
412 | * set by using operator '|' | |
413 | * <pre> | |
414 | * AliHLTComponentDataType dt=kAliHLTDDLRawDataTypeID|kAliHLTDataOriginTPC | |
415 | * </pre> | |
416 | * @ingroup alihlt_component | |
417 | */ | |
418 | ||
32db4144 | 419 | /** |
420 | * @struct AliHLTComponentDataType | |
559631d5 | 421 | * Data type descriptor for data blocks transferred through the processing |
32db4144 | 422 | * chain. |
1ac82ce6 | 423 | * @ingroup alihlt_component_datatypes |
32db4144 | 424 | */ |
8ede8717 | 425 | struct AliHLTComponentDataType |
f23a6e1a | 426 | { |
427 | AliHLTUInt32_t fStructSize; | |
32db4144 | 428 | char fID[kAliHLTComponentDataTypefIDsize]; //! |
429 | char fOrigin[kAliHLTComponentDataTypefOriginSize]; //! | |
f23a6e1a | 430 | }; |
2d7ff710 | 431 | |
32db4144 | 432 | /** |
433 | * @struct AliHLTComponentBlockData | |
3294f81a | 434 | * This is the decription of data blocks exchanged between components. |
435 | * \b IMPORTANT: The validity of fPtr and fOffset is different for input and | |
436 | * output blocks: | |
437 | * - input blocks: The \em fPtr member always points to the beginning of the data | |
438 | * of size \em fSize. fOffset is ignored and should be in most | |
439 | * case 0. | |
440 | * - output blocks: The \em fPtr member is ignored by the framework. \em fOffset | |
441 | * must specify the start of the data relative to the output | |
442 | * buffer. The data block has size \em fSize. | |
32db4144 | 443 | */ |
8ede8717 | 444 | struct AliHLTComponentBlockData |
f23a6e1a | 445 | { |
3294f81a | 446 | /* size and version of the struct */ |
f23a6e1a | 447 | AliHLTUInt32_t fStructSize; |
3294f81a | 448 | /* shared memory key, ignored by processing components */ |
8ede8717 | 449 | AliHLTComponentShmData fShmKey; |
3294f81a | 450 | /* offset of output data relative to the output buffer */ |
f23a6e1a | 451 | AliHLTUInt32_t fOffset; |
3294f81a | 452 | /* start of the data for input data blocks, fOffset to be ignored*/ |
f23a6e1a | 453 | void* fPtr; |
3294f81a | 454 | /* size of the data block */ |
f23a6e1a | 455 | AliHLTUInt32_t fSize; |
3294f81a | 456 | /* data type of the data block */ |
8ede8717 | 457 | AliHLTComponentDataType fDataType; |
3294f81a | 458 | /* data specification of the data block */ |
f23a6e1a | 459 | AliHLTUInt32_t fSpecification; |
460 | }; | |
461 | ||
32db4144 | 462 | /** |
463 | * @struct AliHLTComponentEventDoneData | |
464 | * | |
465 | */ | |
8ede8717 | 466 | struct AliHLTComponentEventDoneData |
f23a6e1a | 467 | { |
468 | AliHLTUInt32_t fStructSize; | |
469 | AliHLTUInt32_t fDataSize; | |
470 | void* fData; | |
471 | }; | |
472 | ||
32db4144 | 473 | /** |
2cbdb37e | 474 | * @struct AliHLTRunDesc |
32db4144 | 475 | * Event descriptor. |
45c0a780 | 476 | * The struct is sent with the SOR and EOR events. |
477 | * | |
478 | * @note | |
479 | * Originally, run type was supposed to be a number and part | |
480 | * of the run descriptor. But it was defined as string later. | |
481 | * The string is passed as argument of the AliHLT_C_SetRunDescription | |
482 | * interface function. | |
32db4144 | 483 | */ |
2cbdb37e | 484 | struct AliHLTRunDesc |
32db4144 | 485 | { |
486 | AliHLTUInt32_t fStructSize; | |
487 | AliHLTUInt32_t fRunNo; | |
488 | AliHLTUInt32_t fRunType; | |
489 | }; | |
490 | ||
a0aeb701 | 491 | /** |
492 | * @struct AliHLTComponentStatistics | |
493 | * Small block size summary added by the AliHLTComponent base class | |
494 | * if component statistics are enabled (--enable-compstat). | |
495 | * | |
496 | * fLevel is retrieved from incoming block statistics and incremented. | |
497 | * Incoming block statistics are appended to the newly added one if | |
498 | * --enable-compstat=full has been chosen. | |
499 | */ | |
500 | struct AliHLTComponentStatistics | |
501 | { | |
502 | AliHLTUInt32_t fStructSize; | |
503 | AliHLTUInt32_t fLevel; | |
504 | AliHLTUInt32_t fId; | |
505 | AliHLTUInt32_t fTime; | |
506 | AliHLTUInt32_t fCTime; | |
507 | AliHLTUInt32_t fInputBlockCount; | |
508 | AliHLTUInt32_t fTotalInputSize; | |
509 | AliHLTUInt32_t fOutputBlockCount; | |
510 | AliHLTUInt32_t fTotalOutputSize; | |
511 | }; | |
512 | ||
513 | /** | |
514 | * @struct AliHLTComponentTableEntry | |
515 | * Structure to be send on SOR event through the chain. Each component | |
516 | * adds its chain id and component arguments to the list. | |
517 | * The 'length' of the structure is variable and depends on the length | |
518 | * of the strings in the buffer at the end. | |
519 | */ | |
520 | struct AliHLTComponentTableEntry | |
521 | { | |
522 | AliHLTUInt32_t fStructSize; | |
523 | /** the 32bit Id is generated by a CRC algorithm from the | |
524 | chain Id of the component. This is not a 100% unique id | |
525 | but with a high probability */ | |
526 | AliHLTUInt32_t fId; | |
527 | /** size of the chain id string in the appended buffer */ | |
528 | AliHLTUInt8_t fSizeChainId; | |
529 | /** size of the comp argument string in the appended buffer */ | |
530 | AliHLTUInt8_t fSizeCompArgs; | |
531 | /** some reserved size */ | |
532 | AliHLTUInt8_t fSizeReserved; | |
533 | /** the strings: chain id, component args, reserved */ | |
534 | AliHLTUInt8_t fBuffer[1]; | |
535 | }; | |
536 | ||
8f81abf4 | 537 | ////////////////////////////////////////////////////////////////////////// |
538 | // | |
539 | // Trigger meta information | |
540 | // | |
541 | ////////////////////////////////////////////////////////////////////////// | |
542 | ||
543 | /** field size of fAttribute */ | |
2ff24e4c | 544 | const int gkAliHLTBlockDAttributeCount = 8; |
8f81abf4 | 545 | |
546 | /** field size of fCommonHeader */ | |
2ff24e4c | 547 | const int gkAliHLTCommonHeaderCount = 8; |
8f81abf4 | 548 | |
32db4144 | 549 | /** size of the DDL list */ |
2ff24e4c | 550 | const int gkAliHLTDDLListSize = 30; |
551 | ||
552 | /** Number of Trigger Classes of CTP in CDH */ | |
553 | const int gkNCTPTriggerClasses = 50; | |
32db4144 | 554 | |
555 | /** | |
556 | * @struct AliHLTEventDDL | |
557 | * DDL list event. | |
558 | * The struct is send with the DDLLIST event. | |
8f81abf4 | 559 | * Used in the trigger structure for internal apperance of |
560 | * the DLLs as well as for the HLT readout list send to DAQ | |
511b2509 | 561 | * ( as DataType : kAliHLTDataTypeDDL ) |
32db4144 | 562 | */ |
563 | struct AliHLTEventDDL | |
564 | { | |
565 | AliHLTUInt32_t fCount; | |
566 | AliHLTUInt32_t fList[gkAliHLTDDLListSize]; | |
567 | }; | |
568 | ||
8f81abf4 | 569 | /** |
570 | * @struct AliHLTEventTriggerData | |
8f81abf4 | 571 | */ |
572 | struct AliHLTEventTriggerData | |
573 | { | |
8f81abf4 | 574 | AliHLTUInt8_t fAttributes[gkAliHLTBlockDAttributeCount]; |
511b2509 | 575 | AliHLTUInt64_t fHLTStatus; // Bit field |
8f81abf4 | 576 | AliHLTUInt32_t fCommonHeaderWordCnt; |
577 | AliHLTUInt32_t fCommonHeader[gkAliHLTCommonHeaderCount]; | |
8f81abf4 | 578 | AliHLTEventDDL fReadoutList; |
579 | }; | |
580 | ||
581 | /** | |
582 | * @struct AliHLTComponentTriggerData | |
583 | * Trigger data | |
584 | */ | |
585 | struct AliHLTComponentTriggerData | |
586 | { | |
587 | AliHLTUInt32_t fStructSize; | |
588 | AliHLTUInt32_t fDataSize; | |
589 | void* fData; | |
590 | }; | |
591 | ||
9d9ffd37 | 592 | ////////////////////////////////////////////////////////////////////////// |
593 | // | |
594 | // HLT Event Type Specification | |
595 | // | |
596 | ////////////////////////////////////////////////////////////////////////// | |
597 | ||
598 | /** Unknown eventType specification */ | |
2ff24e4c | 599 | const AliHLTUInt32_t gkAliEventTypeUnknown = ~(AliHLTUInt32_t)0; |
9d9ffd37 | 600 | /** SOR eventType specification */ |
2ff24e4c | 601 | const AliHLTUInt32_t gkAliEventTypeStartOfRun=1; |
9d9ffd37 | 602 | /** Data eventType specification */ |
2ff24e4c | 603 | const AliHLTUInt32_t gkAliEventTypeData=2; |
9d9ffd37 | 604 | /** EOR eventType specification */ |
2ff24e4c | 605 | const AliHLTUInt32_t gkAliEventTypeEndOfRun=4; |
9d9ffd37 | 606 | /** Corrupt eventType specification */ |
2ff24e4c | 607 | const AliHLTUInt32_t gkAliEventTypeCorruptID=8; |
9d9ffd37 | 608 | /** Calibration eventType specification */ |
2ff24e4c | 609 | const AliHLTUInt32_t gkAliEventTypeCalibration=16; |
9d9ffd37 | 610 | /** DataReplay eventType specification */ |
2ff24e4c | 611 | const AliHLTUInt32_t gkAliEventTypeDataReplay=32; |
b543e186 | 612 | /** Configuration eventType specification */ |
2ff24e4c | 613 | const AliHLTUInt32_t gkAliEventTypeConfiguration=34; |
d6b69874 | 614 | /** Update DCS eventType specification */ |
2ff24e4c | 615 | const AliHLTUInt32_t gkAliEventTypeReadPreprocessor=35; |
9d9ffd37 | 616 | /** Tick eventType specification */ |
2ff24e4c | 617 | const AliHLTUInt32_t gkAliEventTypeTick=64; |
9d9ffd37 | 618 | /** Max eventType specification */ |
2ff24e4c | 619 | const AliHLTUInt32_t gkAliEventTypeMax=64; |
9d9ffd37 | 620 | |
32db4144 | 621 | ////////////////////////////////////////////////////////////////////////// |
622 | // | |
623 | // HLT defines and defaults | |
624 | // | |
625 | ////////////////////////////////////////////////////////////////////////// | |
626 | ||
1ac82ce6 | 627 | /** invalid event id |
628 | * @ingroup alihlt_component_datatypes | |
629 | */ | |
32db4144 | 630 | const AliHLTEventID_t kAliHLTVoidEventID=~(AliHLTEventID_t)0; |
631 | ||
1ac82ce6 | 632 | /** invalid data specification |
633 | * @ingroup alihlt_component_datatypes | |
634 | */ | |
32db4144 | 635 | const AliHLTUInt32_t kAliHLTVoidDataSpec = ~(AliHLTUInt32_t)0; |
636 | ||
45c0a780 | 637 | /** invalid run no |
638 | * @ingroup alihlt_component_datatypes | |
639 | */ | |
640 | const AliHLTUInt32_t kAliHLTVoidRunNo = ~(AliHLTUInt32_t)0; | |
641 | ||
642 | /** invalid run type | |
643 | * @ingroup alihlt_component_datatypes | |
644 | */ | |
645 | const AliHLTUInt32_t kAliHLTVoidRunType = ~(AliHLTUInt32_t)0; | |
646 | ||
647 | /** invalid run descriptor | |
648 | * @ingroup alihlt_component_datatypes | |
649 | */ | |
650 | const AliHLTRunDesc kAliHLTVoidRunDesc={sizeof(AliHLTRunDesc), kAliHLTVoidRunNo, kAliHLTVoidRunType}; | |
651 | ||
32db4144 | 652 | /** invalid shared memory type */ |
653 | const AliHLTUInt32_t gkAliHLTComponentInvalidShmType = 0; | |
654 | ||
655 | /** invalid shared memory id */ | |
656 | const AliHLTUInt64_t gkAliHLTComponentInvalidShmID = ~(AliHLTUInt64_t)0; | |
657 | ||
1ac82ce6 | 658 | /** invalid data type |
659 | * @ingroup alihlt_component_datatypes | |
660 | */ | |
32db4144 | 661 | const AliHLTComponentDataType kAliHLTVoidDataType = { |
662 | sizeof(AliHLTComponentDataType), | |
663 | kAliHLTVoidDataTypeID, | |
3f850585 | 664 | kAliHLTDataOriginVoid |
32db4144 | 665 | }; |
666 | ||
3dd8541e | 667 | /** all data types, means any + void data type |
668 | * @ingroup alihlt_component_datatypes | |
669 | */ | |
670 | const AliHLTComponentDataType kAliHLTAllDataTypes = { | |
671 | sizeof(AliHLTComponentDataType), | |
672 | kAliHLTAllDataTypesID, | |
673 | kAliHLTDataOriginAny | |
674 | }; | |
675 | ||
32db4144 | 676 | // there is currently a problem with rootcint if the predefined ids |
677 | // (commented below) are used. rootcint does not find the id if they | |
678 | // are char arrays defined with {} and individual chars. If strings | |
679 | // are used it works fine | |
1ac82ce6 | 680 | /** any data type |
681 | * @ingroup alihlt_component_datatypes | |
682 | */ | |
32db4144 | 683 | const AliHLTComponentDataType kAliHLTAnyDataType = { |
684 | sizeof(AliHLTComponentDataType), | |
685 | kAliHLTAnyDataTypeID, | |
3f850585 | 686 | kAliHLTDataOriginAny |
32db4144 | 687 | }; |
688 | ||
1ac82ce6 | 689 | /** multiple output data types |
690 | * @ingroup alihlt_component_datatypes | |
691 | */ | |
de6593d0 | 692 | extern const AliHLTComponentDataType kAliHLTMultipleDataType; |
693 | ||
1ac82ce6 | 694 | /** data to file exchange subscriber |
695 | * @ingroup alihlt_component_datatypes | |
696 | */ | |
32db4144 | 697 | extern const AliHLTComponentDataType kAliHLTDataTypeFXSCalib; |
698 | ||
1ac82ce6 | 699 | /** DDL list data type |
700 | * @ingroup alihlt_component_datatypes | |
701 | */ | |
32db4144 | 702 | extern const AliHLTComponentDataType kAliHLTDataTypeDDL; |
703 | ||
1ac82ce6 | 704 | /** SOR data type |
705 | * @ingroup alihlt_component_datatypes | |
706 | */ | |
32db4144 | 707 | extern const AliHLTComponentDataType kAliHLTDataTypeSOR; |
708 | ||
1ac82ce6 | 709 | /** EOR data type |
710 | * @ingroup alihlt_component_datatypes | |
711 | */ | |
32db4144 | 712 | extern const AliHLTComponentDataType kAliHLTDataTypeEOR; |
5ec8e281 | 713 | |
45c0a780 | 714 | /** Run type data block |
715 | * @ingroup alihlt_component_datatypes | |
716 | */ | |
717 | extern const AliHLTComponentDataType kAliHLTDataTypeRunType; | |
718 | ||
1ac82ce6 | 719 | /** Event type specification |
720 | * @ingroup alihlt_component_datatypes | |
721 | */ | |
77405890 | 722 | extern const AliHLTComponentDataType kAliHLTDataTypeEvent; |
723 | ||
1ac82ce6 | 724 | /** Configuration event data type |
725 | * @ingroup alihlt_component_datatypes | |
726 | */ | |
853121af | 727 | extern const AliHLTComponentDataType kAliHLTDataTypeComConf; |
728 | ||
1ac82ce6 | 729 | /** DCS value update event |
730 | * @ingroup alihlt_component_datatypes | |
731 | */ | |
b543e186 | 732 | extern const AliHLTComponentDataType kAliHLTDataTypeUpdtDCS; |
733 | ||
1ac82ce6 | 734 | /** RAW DDL data specification, origin is 'any', data publisher origin correctly |
735 | * @ingroup alihlt_component_datatypes | |
736 | */ | |
3f850585 | 737 | extern const AliHLTComponentDataType kAliHLTDataTypeDDLRaw; |
738 | ||
1ac82ce6 | 739 | /** ESD object data specification, origin is 'any' |
740 | * @ingroup alihlt_component_datatypes | |
741 | */ | |
a978c0d5 | 742 | extern const AliHLTComponentDataType kAliHLTDataTypeESDObject; |
743 | ||
1ac82ce6 | 744 | /** ESD Tree data specification, origin is 'any' |
745 | ||
746 | * @ingroup alihlt_component_datatypes | |
747 | */ | |
c704e290 | 748 | extern const AliHLTComponentDataType kAliHLTDataTypeESDTree; |
749 | ||
1ac82ce6 | 750 | /** AliRoot TreeD data specification, origin is 'any' |
751 | * @ingroup alihlt_component_datatypes | |
752 | */ | |
753 | extern const AliHLTComponentDataType kAliHLTDataTypeAliTreeD; | |
754 | ||
755 | /** AliRoot TreeR data specification, origin is 'any' | |
756 | * @ingroup alihlt_component_datatypes | |
757 | */ | |
758 | extern const AliHLTComponentDataType kAliHLTDataTypeAliTreeR; | |
759 | ||
760 | /** 16 bit Hardware address selection data specification, origin is 'any' | |
761 | * @ingroup alihlt_component_datatypes | |
762 | */ | |
64defa03 | 763 | extern const AliHLTComponentDataType kAliHLTDataTypeHwAddr16; |
764 | ||
1ac82ce6 | 765 | /** Event statistics |
766 | * @ingroup alihlt_component_datatypes | |
767 | */ | |
2ff24e4c | 768 | extern const AliHLTComponentDataType kAliHLTDataTypeEventStatistics; |
769 | ||
1ac82ce6 | 770 | /** Event summary |
771 | * @ingroup alihlt_component_datatypes | |
772 | */ | |
2ff24e4c | 773 | extern const AliHLTComponentDataType kAliHLTDataTypeEventSummary; |
774 | ||
1ac82ce6 | 775 | /** Event statistics |
776 | * @ingroup alihlt_component_datatypes | |
777 | */ | |
2ff24e4c | 778 | extern const AliHLTComponentDataType kAliHLTDataTypeRunStatistics; |
779 | ||
1ac82ce6 | 780 | /** Event summary |
781 | * @ingroup alihlt_component_datatypes | |
782 | */ | |
2ff24e4c | 783 | extern const AliHLTComponentDataType kAliHLTDataTypeRunSummary; |
784 | ||
a0aeb701 | 785 | /** Component block statistics |
786 | * @ingroup alihlt_component_datatypes | |
787 | */ | |
788 | extern const AliHLTComponentDataType kAliHLTDataTypeComponentStatistics; | |
789 | ||
790 | /** Component table | |
791 | * To be sent on SOR event, each component adds it's chain id string | |
792 | * and a generated 32bit identifier to the table | |
793 | * @ingroup alihlt_component_datatypes | |
794 | */ | |
795 | extern const AliHLTComponentDataType kAliHLTDataTypeComponentTable; | |
796 | ||
c736de25 | 797 | ////////////////////////////////////////////////////////////////////////// |
798 | // | |
799 | // Data Types for Monitoring objects | |
800 | // | |
801 | ////////////////////////////////////////////////////////////////////////// | |
802 | ||
1ac82ce6 | 803 | /** general ROOT TObject |
804 | * @ingroup alihlt_component_datatypes | |
805 | */ | |
c736de25 | 806 | extern const AliHLTComponentDataType kAliHLTDataTypeTObject; // {ROOTTOBJ,"***"} |
807 | ||
1ac82ce6 | 808 | /** ROOT TObjArray |
809 | * @ingroup alihlt_component_datatypes | |
810 | */ | |
c736de25 | 811 | extern const AliHLTComponentDataType kAliHLTDataTypeTObjArray; // {ROOTOBAR,"***"} |
812 | ||
1ac82ce6 | 813 | /** ROOT TTree |
814 | * @ingroup alihlt_component_datatypes | |
815 | */ | |
c736de25 | 816 | extern const AliHLTComponentDataType kAliHLTDataTypeTTree; // {ROOTTREE,"***"} |
817 | ||
1ac82ce6 | 818 | /** ROOT TH1 (can be used for all histograms, they derive from TH1) |
819 | * @ingroup alihlt_component_datatypes | |
820 | */ | |
c736de25 | 821 | extern const AliHLTComponentDataType kAliHLTDataTypeHistogram; // {ROOTHIST,"***"} |
822 | ||
1ac82ce6 | 823 | /** ROOT TNtuple |
824 | * @ingroup alihlt_component_datatypes | |
825 | */ | |
c736de25 | 826 | extern const AliHLTComponentDataType kAliHLTDataTypeTNtuple; // {ROOTTUPL,"***"} |
827 | ||
32db4144 | 828 | ////////////////////////////////////////////////////////////////////////// |
829 | // | |
830 | // FXS subscriber meta information | |
831 | // | |
832 | ////////////////////////////////////////////////////////////////////////// | |
833 | ||
2ff24e4c | 834 | const int gkAliHLTFXSHeaderfOriginSize = 4; |
835 | const int gkAliHLTFXSHeaderfFileIDSize = 128; | |
836 | const int gkAliHLTFXSHeaderfDDLNumberSize = 64; | |
32db4144 | 837 | |
838 | /** Header in front of the data payload, in order to sent data to the FXS. */ | |
839 | struct AliHLTFXSHeader | |
840 | { | |
841 | AliHLTUInt32_t fHeaderVersion; | |
842 | AliHLTUInt32_t fRunNumber; | |
843 | char fOrigin[gkAliHLTFXSHeaderfOriginSize]; | |
844 | char fFileID[gkAliHLTFXSHeaderfFileIDSize]; | |
845 | char fDDLNumber[gkAliHLTFXSHeaderfDDLNumberSize]; | |
846 | }; | |
847 | ||
848 | ////////////////////////////////////////////////////////////////////////// | |
849 | // | |
850 | // Component running environment | |
851 | // | |
852 | ////////////////////////////////////////////////////////////////////////// | |
853 | ||
854 | /** logging function */ | |
855 | typedef int (*AliHLTfctLogging)( void* param, | |
856 | AliHLTComponentLogSeverity severity, | |
857 | const char* origin, | |
858 | const char* keyword, | |
859 | const char* message); | |
860 | ||
861 | /** | |
862 | * @struct AliHLTComponentEnvironment | |
863 | * Running environment for analysis components. | |
864 | * The struct describes function callbacks for | |
865 | */ | |
f23a6e1a | 866 | struct AliHLTComponentEnvironment |
867 | { | |
868 | AliHLTUInt32_t fStructSize; | |
869 | void* fParam; | |
870 | void* (*fAllocMemoryFunc)( void* param, unsigned long size ); | |
871 | #if 0 | |
32db4144 | 872 | // future addition already foreseen/envisioned |
873 | // IMPORTANT: don not just remove the defines as this breaks the binary | |
874 | // compatibility | |
875 | int (*fAllocShmMemoryFunc)( void* param, unsigned long size, AliHLTComponentBlockData* blockLocation ); | |
f23a6e1a | 876 | #endif |
8ede8717 | 877 | int (*fGetEventDoneDataFunc)( void* param, AliHLTEventID_t eventID, unsigned long size, AliHLTComponentEventDoneData** edd ); |
5ec8e281 | 878 | AliHLTfctLogging fLoggingFunc; |
f23a6e1a | 879 | }; |
880 | } | |
881 | ||
32db4144 | 882 | ////////////////////////////////////////////////////////////////////////// |
883 | // | |
884 | // Data type helper functions | |
885 | // | |
886 | ////////////////////////////////////////////////////////////////////////// | |
887 | ||
3dd8541e | 888 | /** exact comparison of HLT component data types |
889 | * @ingroup alihlt_component_datatypes | |
890 | */ | |
891 | inline bool MatchExactly( const AliHLTComponentDataType& dt1, const AliHLTComponentDataType& dt2 ) | |
892 | { | |
893 | for ( int i = 0; i < kAliHLTComponentDataTypefIDsize; i++ ) | |
894 | if ( dt1.fID[i] != dt2.fID[i] ) | |
895 | return false; | |
896 | for ( int i = 0; i < kAliHLTComponentDataTypefOriginSize; i++ ) | |
897 | if ( dt1.fOrigin[i] != dt2.fOrigin[i] ) | |
898 | return false; | |
899 | return true; | |
900 | } | |
901 | ||
1ac82ce6 | 902 | /** Comparison operator for HLT component data types. |
903 | * The operator takes wildcards into account, i.e. the ::kAliHLTAnyDataType, | |
904 | * ::kAliHLTAnyDataTypeID and ::kAliHLTDataOriginAny definitions. | |
905 | * @ingroup alihlt_component_datatypes | |
906 | */ | |
8ede8717 | 907 | inline bool operator==( const AliHLTComponentDataType& dt1, const AliHLTComponentDataType& dt2 ) |
853121af | 908 | { |
3dd8541e | 909 | if (MatchExactly(dt1, kAliHLTAllDataTypes)) return true; |
910 | if (MatchExactly(dt2, kAliHLTAllDataTypes)) return true; | |
911 | ||
853121af | 912 | bool any1=true, any2=true, void1=true, void2=true, match=true; |
913 | for ( int i = 0; i < kAliHLTComponentDataTypefOriginSize; i++ ) { | |
914 | any1&=(dt1.fOrigin[i]==kAliHLTDataOriginAny[i]); | |
915 | any2&=(dt2.fOrigin[i]==kAliHLTDataOriginAny[i]); | |
916 | void1&=(dt1.fOrigin[i]==kAliHLTDataOriginVoid[i]); | |
917 | void2&=(dt2.fOrigin[i]==kAliHLTDataOriginVoid[i]); | |
918 | match&=dt1.fOrigin[i]==dt2.fOrigin[i]; | |
919 | if (!(match || (any2 && !void1) || (any1 && !void2))) | |
920 | return false; | |
921 | } | |
922 | ||
923 | any1=true, any2=true, match=true; | |
924 | for ( int i = 0; i < kAliHLTComponentDataTypefIDsize; i++ ) { | |
925 | any1&=(dt1.fID[i]==kAliHLTAnyDataTypeID[i]); | |
926 | any2&=(dt2.fID[i]==kAliHLTAnyDataTypeID[i]); | |
927 | void1&=(dt1.fID[i]==kAliHLTVoidDataTypeID[i]); | |
928 | void2&=(dt2.fID[i]==kAliHLTVoidDataTypeID[i]); | |
929 | match&=dt1.fID[i]==dt2.fID[i]; | |
930 | if (!(match || (any2 && !void1) || (any1 && !void2))) | |
931 | return false; | |
932 | } | |
933 | return true; | |
934 | } | |
71d7c760 | 935 | |
1ac82ce6 | 936 | /** Comparison operator for HLT component data types |
297174de | 937 | * Invers of operator== |
1ac82ce6 | 938 | * @ingroup alihlt_component_datatypes |
939 | */ | |
8ede8717 | 940 | inline bool operator!=( const AliHLTComponentDataType& dt1, const AliHLTComponentDataType& dt2 ) |
853121af | 941 | { |
942 | return !(dt1==dt2); | |
943 | } | |
71d7c760 | 944 | |
1ac82ce6 | 945 | /** merge operator for HLT component data types and origins |
946 | * @ingroup alihlt_component_datatypes | |
947 | */ | |
69347e0d | 948 | inline AliHLTComponentDataType operator|(const AliHLTComponentDataType srcdt, const char origin[kAliHLTComponentDataTypefOriginSize]) |
853121af | 949 | { |
950 | AliHLTComponentDataType dt=srcdt; | |
951 | for ( int i = 0; i < kAliHLTComponentDataTypefOriginSize; i++ ) | |
952 | dt.fOrigin[i]=origin[i]; | |
953 | return dt; | |
954 | } | |
32db4144 | 955 | |
f23a6e1a | 956 | #endif |