X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=HLT%2FBASE%2FAliHLTDataTypes.h;h=18688a43236d99a414bf26dbd36d19755be60bb2;hb=80d83a6587cbcea2922011f991ead3ee79bdda63;hp=299f4f189c7cb3a5478f2cb0862e47c0c990cefe;hpb=d9dd3bc8219369006d5e5a2cbcad0c8359539322;p=u%2Fmrichter%2FAliRoot.git diff --git a/HLT/BASE/AliHLTDataTypes.h b/HLT/BASE/AliHLTDataTypes.h index 299f4f189c7..18688a43236 100644 --- a/HLT/BASE/AliHLTDataTypes.h +++ b/HLT/BASE/AliHLTDataTypes.h @@ -33,8 +33,42 @@ * 6 Common data types for TreeD and TreeR defined * kAliHLTAllDataTypes and kAliHLTDataOriginSample added * kAliHLTDataOriginEMCAL added + * kAliHLTDataTypeRunType added + * 7 kAliHLTDataTypeComponentStatistics, kAliHLTDataTypeComponentTable, + * and AliHLTComponentStatistics have been added for optional + * component block statistics + * 8 new wrapper interface has been introduced, old wrapper interface + * deprecated but kept for backward compatibility, the PubSub + * interface is going to be compiled independently of AliHLT, new + * interface provided by the libHLTinterface.so + * AliHLTComponentEnvironment -> AliHLTAnalysisEnvironment + * 9 added data types for arrays of AliHLTExternalTrackParam sets and + * TClonesArrays of AliExternalTrackParam objects. + * 10 Changes for information objects neededfor running with offline + * chains and analysis tasks. + * kAliHLTMCObjectDataType added + * kAliHLTDataOriginOffline added + * kAliHLTDataOriginHLT added + * 11 extended AliHLTComponentStatistics: one more member to store the + * cycle time between events per component. + * 12 added common data type id 'CLUSTERS' + * added data type 'ECSPARAM' for the full ECS parameter string to + * be sebt during SOR + * added kAliHLTDataTypeTrackMC (TRACK_MC) data type + * added data types (note: interface version stays the same + * kAliHLTDataTypeDAQRDOUT (DAQRDOUT) + * kAliHLTDataTypeTriggerDecision (TRIG_DEC) + * kAliHLTDataTypeGlobalTrigger (GLOBTRIG) + * kAliHLTDataTypeStreamerInfo (ROOTSTRI) + * 13 Changed AliHLTEventDDL to now contain 31 words. The extra word is + * for the EMCAL detector, which needs 46 DDLs after DCAL was added. + * 14 Adding new data block type for HLT global trigger counters. + * Adding data block type for ESD content + * Adding data block type for forwarded component table blocks + * Adding new event type for software triggers. + * 15 Modifying data block types for trigger counter blocks. */ -#define ALIHLT_DATA_TYPES_VERSION 6 +#define ALIHLT_DATA_TYPES_VERSION 15 ////////////////////////////////////////////////////////////////////////// // @@ -44,7 +78,7 @@ // the operator| // // AliHLTComponentDataType dt; -// dt = kAliHLTDataTypeDDLRaw | gkAliHLTDataOriginTPC; +// dt = kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC; // ////////////////////////////////////////////////////////////////////////// @@ -73,6 +107,17 @@ const int kAliHLTComponentDataTypefOriginSize=4; */ extern const char kAliHLTDataOriginOut[kAliHLTComponentDataTypefOriginSize]; +/** Data origin HLT, used for HLT specifc data + * in offline chains. This not a bug! + * @ingroup alihlt_component_datatypes + */ +extern const char kAliHLTDataOriginHLT[kAliHLTComponentDataTypefOriginSize]; + +/** Data origin Offline + * @ingroup alihlt_component_datatypes + */ +extern const char kAliHLTDataOriginOffline[kAliHLTComponentDataTypefOriginSize]; + /** Data origin HLT/PubSub private internal * @ingroup alihlt_component_datatypes */ @@ -88,6 +133,11 @@ extern const char kAliHLTDataOriginTPC[kAliHLTComponentDataTypefOriginSize]; */ extern const char kAliHLTDataOriginPHOS[kAliHLTComponentDataTypefOriginSize]; +/** Data origin FMD + * @ingroup alihlt_component_datatypes + */ +extern const char kAliHLTDataOriginFMD[kAliHLTComponentDataTypefOriginSize]; + /** Data origin MUON * @ingroup alihlt_component_datatypes */ @@ -103,6 +153,26 @@ extern const char kAliHLTDataOriginTRD[kAliHLTComponentDataTypefOriginSize]; */ extern const char kAliHLTDataOriginITS[kAliHLTComponentDataTypefOriginSize]; +/** Data origin ITSOut + * @ingroup alihlt_component_datatypes + */ +extern const char kAliHLTDataOriginITSOut[kAliHLTComponentDataTypefOriginSize]; + +/** Data origin ITS SPD + * @ingroup alihlt_component_datatypes + */ +extern const char kAliHLTDataOriginITSSPD[kAliHLTComponentDataTypefOriginSize]; + +/** Data origin ITS SDD + * @ingroup alihlt_component_datatypes + */ +extern const char kAliHLTDataOriginITSSDD[kAliHLTComponentDataTypefOriginSize]; + +/** Data origin ITS SSD + * @ingroup alihlt_component_datatypes + */ +extern const char kAliHLTDataOriginITSSSD[kAliHLTComponentDataTypefOriginSize]; + /** Data origin for examples * @ingroup alihlt_component_datatypes */ @@ -113,6 +183,52 @@ extern const char kAliHLTDataOriginSample[kAliHLTComponentDataTypefOriginSize]; */ extern const char kAliHLTDataOriginEMCAL[kAliHLTComponentDataTypefOriginSize]; +/** Data origin TOF + * @ingroup alihlt_component_datatypes + */ +extern const char kAliHLTDataOriginTOF[kAliHLTComponentDataTypefOriginSize]; + +/** Data origin HMPID + * @ingroup alihlt_component_datatypes + */ +extern const char kAliHLTDataOriginHMPID[kAliHLTComponentDataTypefOriginSize]; + +/** Data origin CPV + * @ingroup alihlt_component_datatypes + */ +extern const char kAliHLTDataOriginCPV[kAliHLTComponentDataTypefOriginSize]; + +/** Data origin PMD + * @ingroup alihlt_component_datatypes + */ +extern const char kAliHLTDataOriginPMD[kAliHLTComponentDataTypefOriginSize]; + +/** Data origin T0 + * @ingroup alihlt_component_datatypes + */ +extern const char kAliHLTDataOriginT0[kAliHLTComponentDataTypefOriginSize]; + +/** Data origin VZERO + * @ingroup alihlt_component_datatypes + */ +extern const char kAliHLTDataOriginVZERO[kAliHLTComponentDataTypefOriginSize]; + +/** Data origin ZDC + * @ingroup alihlt_component_datatypes + */ +extern const char kAliHLTDataOriginZDC[kAliHLTComponentDataTypefOriginSize]; + +/** Data origin ACORDE + * @ingroup alihlt_component_datatypes + */ + +extern const char kAliHLTDataOriginACORDE[kAliHLTComponentDataTypefOriginSize]; + +/** Data origin TRG + * @ingroup alihlt_component_datatypes + */ +extern const char kAliHLTDataOriginTRG[kAliHLTComponentDataTypefOriginSize]; + ////////////////////////////////////////////////////////////////////////// // // HLT common data type defines @@ -145,6 +261,13 @@ const int kAliHLTComponentDataTypefIDsize=8; */ # define kAliHLTDDLRawDataTypeID {'D','D','L','_','R','A','W',' '} +/** CLUSTERS data + * Common data type for the output of cluster finders, the exact + * format depends on the origin (detector) + * @ingroup alihlt_component_datatypes + */ +# define kAliHLTClustersDataTypeID {'C','L','U','S','T','E','R','S'} + /** calibration data for file exchange subscriber * @ingroup alihlt_component_datatypes */ @@ -162,18 +285,41 @@ const int kAliHLTComponentDataTypefIDsize=8; */ # define kAliHLTEORDataTypeID {'E','N','D','O','F','R','U','N'} +/** run type data block + * string with run type as payload + * @ingroup alihlt_component_datatypes + */ +# define kAliHLTRunTypeDataTypeID {'R','U','N','T','Y','P','E',' '} + /** DDL list event * @ref AliHLTEventDDL * @ingroup alihlt_component_datatypes */ # define kAliHLTDDLDataTypeID {'D','D','L','L','I','S','T',' '} +/** DAQ readout list + * @ingroup alihlt_component_datatypes + */ +# define kAliHLTDAQRDOUTDataTypeID "DAQRDOUT" + +/** HLT readout list. + * @ingroup alihlt_component_datatypes + */ +# define kAliHLTReadoutListDataTypeID {'H','L','T','R','D','L','S','T'} + /** EventType event * - empty payload, specification gives eventType * @ingroup alihlt_component_datatypes */ # define kAliHLTEventDataTypeID {'E','V','E','N','T','T','Y','P'} +/** ECS parameter event + * - sent during the SOR event by the framework + * - contains the full ECS parameter string + * @ingroup alihlt_component_datatypes + */ +# define kAliHLTECSParamDataTypeID {'E','C','S','P','A','R','A','M'} + /** ComponentConfiguration event * - payload contains the CDB path as string * @ingroup alihlt_component_datatypes @@ -186,6 +332,26 @@ const int kAliHLTComponentDataTypefIDsize=8; */ # define kAliHLTUpdtDCSDataTypeID {'U','P','D','T','_','D','C','S'} +/** MC data block + * an AliMCEvent object of varying origin + * The 'V0' at the end allows a versioning + * @ingroup alihlt_component_datatypes + */ +# define kAliHLTMCObjectDataTypeID {'A','L','I','M','C','_','V','0'} + +/** ESDVertex data block + * an AliESDVertex object of varying origin + * The 'V0' at the end allows a versioning + * @ingroup alihlt_component_datatypes + */ +# define kAliHLTESDVertexDataTypeID {'E','S','D','V','T','X','V','0'} + +/** output of the GlobalVertexer data block + * The 'V0' at the end allows a versioning + * @ingroup alihlt_component_datatypes + */ +# define kAliHLTDataTypeGlobalVertexerID {'G','L','B','V','T','X','V','0'} + /** ESD data block * an AliESD object of varying origin * The 'V0' at the end allows a versioning @@ -193,6 +359,12 @@ const int kAliHLTComponentDataTypefIDsize=8; */ # define kAliHLTESDObjectDataTypeID {'A','L','I','E','S','D','V','0'} +/** ESD + * data blocks designated for the ESD + * @ingroup alihlt_component_datatypes + */ +# define kAliHLTESDContentDataTypeID {'E','S','D','_','C','O','N','T'} + /** ESD tree data block * TTree with an AliESD object of varying origin * @ingroup alihlt_component_datatypes @@ -209,7 +381,7 @@ const int kAliHLTComponentDataTypefIDsize=8; * - the rec points tree of an AliRoot module * @ingroup alihlt_component_datatypes */ -#define kAliHLTTreeRDataTypeID {'A','L','I','T','R','E','E','D'} +#define kAliHLTTreeRDataTypeID {'A','L','I','T','R','E','E','R'} /** HW Address selection data block * - a selection list for 16 bit HW addresses @@ -246,6 +418,38 @@ const int kAliHLTComponentDataTypefIDsize=8; */ # define kAliHLTRunSummaryDataTypeID {'R','U','N','S','U','M','M','A'} +/** Trigger decision + * - origin : kAliHLTDataOriginOut ( HLT ) + * @ingroup alihlt_component_datatypes + */ +# define kAliHLTTriggerDecisionDataTypeID {'T','R','I','G','_','D','E','C'} + +/** Global trigger decision + * - origin : kAliHLTDataOriginOut ( HLT ) + * @ingroup alihlt_component_datatypes + */ +# define kAliHLTGlobalTriggerDataTypeID {'G','L','O','B','T','R','I','G'} + +/** Block Statistics + * - small block statistics info added to the data stream by + * the component base class + * - origin kAliHLTDataOriginPrivate + * @ingroup alihlt_component_datatypes + */ +# define kAliHLTComponentStatisticsDataTypeID {'C','O','M','P','S','T','A','T'} + +/** Component table + * - list of components in the chain to be percolated through the chain + * - each component adds it's chain id string and a generated 32bit id + * @ingroup alihlt_component_datatypes + */ +# define kAliHLTComponentTableDataTypeID {'C','O','M','P','T','A','B','L'} + +/** Forwarded component table + * @ingroup alihlt_component_datatypes + */ +# define kAliHLTComponentFwdTableDataTypeID {'C','O','M','P','T','A','B','F'} + /** general ROOT TObject * - a general TObject exported from the HLT analysis * - varying origin @@ -253,6 +457,13 @@ const int kAliHLTComponentDataTypefIDsize=8; */ #define kAliHLTTObjectDataTypeID {'R','O','O','T','T','O','B','J'} +/** ROOT streamer info + * - used for the transmission of streamer info for objects in the HLTOUT + * - origin kAliHLTDataOriginOut ( HLT ) + * @ingroup alihlt_component_datatypes + */ +#define kAliHLTStreamerInfoDataTypeID {'R','O','O','T','S','T','R','I'} + /** ROOT TObjArray * - a TObjArray exported from the HLT analysis * - varying origin @@ -282,6 +493,53 @@ const int kAliHLTComponentDataTypefIDsize=8; */ #define kAliHLTTNtupleDataTypeID {'R','O','O','T','T','U','P','L'} +/** HLT Track + * - Struct for Tracks based on AliExternalTrackParam + * - varying origin + * @ingroup alihlt_component_datatypes + */ +#define kAliHLTTrackDataTypeID {'H','L','T','T','R','A','C','K'} + +/** Track Monte Carlo information + * @ingroup alihlt_component_datatypes + */ +#define kAliHLTTrackMCDataTypeID {'T','R','A','C','K','_','M','C'} + +/** TClonesArray of AliExternalTrackParam + * @ingroup alihlt_component_datatypes + */ +#define kAliHLTExternalTrackParamDataTypeID {'T','C','A','E','X','T','T','R'} + +/** HLT Jet + * - Struct for jets based on AliHLTJETJets + * - varying origin + * @ingroup alihlt_component_datatypes + */ +#define kAliHLTJetDataTypeID {'H','L','T','J','E','T','V','0'} + +/** dEdx data + * Common data type for the dEdx + * format depends on the origin (detector) + * @ingroup alihlt_component_datatypes + */ +# define kAliHLTdEdxDataTypeID {'D','E','D','X',' ',' ',' ',' '} + +/** dNdPt data + * Common data type for the dNdPt output object + * @ingroup alihlt_component_datatypes + */ +# define kAliHLTdNdPtDataTypeID {'D','N','D','P','T',' ',' ',' '} + +/** Global input trigger counters data block type. + * @ingroup alihlt_component_datatypes + */ +# define kAliHLTInputTriggerCountersDataTypeID {'I','N','T','R','G','C','N','T'} + +/** Global output trigger counters data block type. + * @ingroup alihlt_component_datatypes + */ +# define kAliHLTOutputTriggerCountersDataTypeID {'O','T','T','R','G','C','N','T'} + using namespace std; extern "C" { @@ -345,7 +603,7 @@ extern "C" { kHLTLogAll = 0x7f, /** the default logging filter */ kHLTLogDefault = 0x79 -}; + }; ////////////////////////////////////////////////////////////////////////// // @@ -359,11 +617,11 @@ extern "C" { */ struct AliHLTComponentEventData { - AliHLTUInt32_t fStructSize; - AliHLTEventID_t fEventID; - AliHLTUInt32_t fEventCreation_s; - AliHLTUInt32_t fEventCreation_us; - AliHLTUInt32_t fBlockCnt; + AliHLTUInt32_t fStructSize; /// Size of this structure in bytes. + AliHLTEventID_t fEventID; /// 64 bit event ID number. + AliHLTUInt32_t fEventCreation_s; /// Event creation time in seconds (Should be added to fEventCreation_us*1e6). + AliHLTUInt32_t fEventCreation_us; /// Fractional event creation time in micro seconds. + AliHLTUInt32_t fBlockCnt; /// The number of raw data blocks received by the component. }; /** @@ -373,9 +631,9 @@ extern "C" { */ struct AliHLTComponentShmData { - AliHLTUInt32_t fStructSize; - AliHLTUInt32_t fShmType; - AliHLTUInt64_t fShmID; + AliHLTUInt32_t fStructSize; /// Size of this structure in bytes. + AliHLTUInt32_t fShmType; /// The type code of the shared memory. + AliHLTUInt64_t fShmID; /// The shared memory identifier. }; /** @@ -399,9 +657,9 @@ extern "C" { */ struct AliHLTComponentDataType { - AliHLTUInt32_t fStructSize; - char fID[kAliHLTComponentDataTypefIDsize]; //! - char fOrigin[kAliHLTComponentDataTypefOriginSize]; //! + AliHLTUInt32_t fStructSize; /// Size of this structure in bytes. + char fID[kAliHLTComponentDataTypefIDsize]; /// Data type identifier. + char fOrigin[kAliHLTComponentDataTypefOriginSize]; /// Subsystem or detector origin of the data. }; /** @@ -418,19 +676,19 @@ extern "C" { */ struct AliHLTComponentBlockData { - /* size and version of the struct */ + /** size and version of the struct */ AliHLTUInt32_t fStructSize; - /* shared memory key, ignored by processing components */ + /** shared memory key, ignored by processing components */ AliHLTComponentShmData fShmKey; - /* offset of output data relative to the output buffer */ + /** offset of output data relative to the output buffer */ AliHLTUInt32_t fOffset; - /* start of the data for input data blocks, fOffset to be ignored*/ + /** start of the data for input data blocks, fOffset to be ignored*/ void* fPtr; - /* size of the data block */ + /** size of the data block */ AliHLTUInt32_t fSize; - /* data type of the data block */ + /** data type of the data block */ AliHLTComponentDataType fDataType; - /* data specification of the data block */ + /** data specification of the data block */ AliHLTUInt32_t fSpecification; }; @@ -440,21 +698,88 @@ extern "C" { */ struct AliHLTComponentEventDoneData { - AliHLTUInt32_t fStructSize; - AliHLTUInt32_t fDataSize; - void* fData; + AliHLTUInt32_t fStructSize; /// Size of this structure in bytes. + AliHLTUInt32_t fDataSize; /// Size of the data section (following this data member) in bytes. + void* fData; /// Start of the data section. }; /** * @struct AliHLTRunDesc * Event descriptor. - * The struct is send with the SOR and EOR events. + * The struct is sent with the SOR and EOR events. + * + * @note + * The name of the member fRunType is a bit misleading. This is not + * the ALICE Run Type given by the ECS to the sub-system. The member + * is an internal HLT run type and a combination of the HLT running + * mode and the beam type. + * 
+   * Bit 0-2:   beam type identifier
+   * Bit 3-31:  HLT mode
+   *
*/ struct AliHLTRunDesc { - AliHLTUInt32_t fStructSize; - AliHLTUInt32_t fRunNo; - AliHLTUInt32_t fRunType; + AliHLTUInt32_t fStructSize; /// Size of this structure in bytes. + AliHLTUInt32_t fRunNo; /// The run number for the current active run. + AliHLTUInt32_t fRunType; /// The HLT run type. + }; + + /** + * @struct AliHLTComponentStatistics + * Small block size summary added by the AliHLTComponent base class + * if component statistics are enabled (--enable-compstat). + * + * fLevel is retrieved from incoming block statistics and incremented. + * Incoming block statistics are appended to the newly added one if + * --enable-compstat=full has been chosen. + * + * ChangeLog: + * 2009-01-14 fComponentCycleTime added + */ + struct AliHLTComponentStatistics + { + AliHLTUInt32_t fStructSize; /// Size of this structure in bytes. + AliHLTUInt32_t fLevel; /// Indicates from which processing stage this information is from. + AliHLTUInt32_t fId; /// Unique identifier for the chain based on CRC code. + AliHLTUInt32_t fTime; /// Real wall time used to process the data (micro seconds). + AliHLTUInt32_t fCTime; /// CPU time used to process the data (micro seconds). + AliHLTUInt32_t fInputBlockCount; /// Number of input data blocks. + AliHLTUInt32_t fTotalInputSize; /// Total size in bytes of input data. + AliHLTUInt32_t fOutputBlockCount; /// Number of output data blocks. + AliHLTUInt32_t fTotalOutputSize; /// Total size in bytes of output data. + AliHLTUInt32_t fComponentCycleTime; /// Real wall time indicating the start of the data processing (micro seconds). + }; + + /** + * @struct AliHLTComponentTableEntry + * Structure to be send on SOR event through the chain. + * The 'length' of the structure is variable and depends on the length + * of the buffer at the end. + * + * ComponentTableEntries are sent with data type @ref kAliHLTDataTypeComponentTable + * and are identified by a 32bit Id specification generated by a CRC + * algorithm from the chain Id of the component. This is not a 100% unique + * id but with a high probability. This approach accounts for the fact + * that all components are separated processes. + * + * The buffer consists of an array of 32bit Ids containing the Ids of + * all direct parents taken from the specification of the data blocks. + * The number of parents is stored in fNofParents. Each component forwards the + * incoming component table entries with data type @ref kAliHLTDataTypeComponentFwdTable + * by that the direct parents can be identified. + * + * Following this array a description string contains the chain id, component args, and + * maybe more properties in the future. The current format is + * 'chain_id{component_id:component args}' e.g. TPC-CF_00_0{TPCClusterFinder32Bit:-deconvolute-time} + */ + struct AliHLTComponentTableEntry + { + AliHLTUInt32_t fStructSize; /// Size of this structure in bytes. + AliHLTUInt32_t fLevel; /// Indicates from which processing stage this information is from. + AliHLTUInt16_t fNofParents; /// size of the array of parent ids + AliHLTUInt8_t fSizeDescription; /// size of the description string in the appended buffer + AliHLTUInt8_t fBuffer[1]; /// the strings: chain id, component args, reserved }; ////////////////////////////////////////////////////////////////////////// @@ -467,38 +792,65 @@ extern "C" { const int gkAliHLTBlockDAttributeCount = 8; /** field size of fCommonHeader */ - const int gkAliHLTCommonHeaderCount = 8; + const int gkAliHLTCommonHeaderCount = 8; + + /** size of the DDL list first version */ + const int gkAliHLTDDLListSizeV0 = 30; + + /** size of the DDL list after DCAL added to EMCAL */ + const int gkAliHLTDDLListSizeV1 = 31; /** size of the DDL list */ - const int gkAliHLTDDLListSize = 30; + const int gkAliHLTDDLListSize = gkAliHLTDDLListSizeV1; /** Number of Trigger Classes of CTP in CDH */ const int gkNCTPTriggerClasses = 50; /** - * @struct AliHLTEventDDL - * DDL list event. + * @struct AliHLTEventDDLV0 + * First version of the DDL list event. * The struct is send with the DDLLIST event. * Used in the trigger structure for internal apperance of * the DLLs as well as for the HLT readout list send to DAQ * ( as DataType : kAliHLTDataTypeDDL ) */ - struct AliHLTEventDDL + struct AliHLTEventDDLV0 { - AliHLTUInt32_t fCount; - AliHLTUInt32_t fList[gkAliHLTDDLListSize]; + AliHLTUInt32_t fCount; /// Indicates the number of words in fList. + AliHLTUInt32_t fList[gkAliHLTDDLListSizeV0]; /// The list of DDL enable/disable bits. }; + /** + * @struct AliHLTEventDDLV1 + * DDL list event structure with extra word for DCAL bits. + */ + struct AliHLTEventDDLV1 + { + AliHLTUInt32_t fCount; /// Indicates the number of words in fList. + AliHLTUInt32_t fList[gkAliHLTDDLListSizeV1]; /// The list of DDL enable/disable bits. + }; + + /** + * @typedef AliHLTEventDDL + * Current used default version of the AliHLTEventDDL structure. + */ + typedef AliHLTEventDDLV1 AliHLTEventDDL; + /** * @struct AliHLTEventTriggerData */ struct AliHLTEventTriggerData { - AliHLTUInt8_t fAttributes[gkAliHLTBlockDAttributeCount]; - AliHLTUInt64_t fHLTStatus; // Bit field - AliHLTUInt32_t fCommonHeaderWordCnt; - AliHLTUInt32_t fCommonHeader[gkAliHLTCommonHeaderCount]; - AliHLTEventDDL fReadoutList; + AliHLTUInt8_t fAttributes[gkAliHLTBlockDAttributeCount]; /// List of data block attibutes. + AliHLTUInt64_t fHLTStatus; /// Bit field + AliHLTUInt32_t fCommonHeaderWordCnt; /// Number of words in fCommonHeader. + AliHLTUInt32_t fCommonHeader[gkAliHLTCommonHeaderCount]; /// The common header words. + union + { + AliHLTEventDDL fReadoutList; /// The default readout list structure. + AliHLTEventDDLV0 fReadoutListV0; /// Access to the old version of the readout list structure. + AliHLTEventDDLV1 fReadoutListV1; /// Access to the readout list structure with DCAL included. + }; }; /** @@ -507,9 +859,9 @@ extern "C" { */ struct AliHLTComponentTriggerData { - AliHLTUInt32_t fStructSize; - AliHLTUInt32_t fDataSize; - void* fData; + AliHLTUInt32_t fStructSize; /// Size of this structure in bytes. + AliHLTUInt32_t fDataSize; /// Size of the data section (following this data member) in bytes. + void* fData; /// Start of the data section. }; ////////////////////////////////////////////////////////////////////////// @@ -530,6 +882,8 @@ extern "C" { const AliHLTUInt32_t gkAliEventTypeCorruptID=8; /** Calibration eventType specification */ const AliHLTUInt32_t gkAliEventTypeCalibration=16; + /** Software eventType specification */ + const AliHLTUInt32_t gkAliEventTypeSoftware=24; /** DataReplay eventType specification */ const AliHLTUInt32_t gkAliEventTypeDataReplay=32; /** Configuration eventType specification */ @@ -557,6 +911,21 @@ extern "C" { */ const AliHLTUInt32_t kAliHLTVoidDataSpec = ~(AliHLTUInt32_t)0; + /** invalid run no + * @ingroup alihlt_component_datatypes + */ + const AliHLTUInt32_t kAliHLTVoidRunNo = ~(AliHLTUInt32_t)0; + + /** invalid run type + * @ingroup alihlt_component_datatypes + */ + const AliHLTUInt32_t kAliHLTVoidRunType = ~(AliHLTUInt32_t)0; + + /** invalid run descriptor + * @ingroup alihlt_component_datatypes + */ + const AliHLTRunDesc kAliHLTVoidRunDesc={sizeof(AliHLTRunDesc), kAliHLTVoidRunNo, kAliHLTVoidRunType}; + /** invalid shared memory type */ const AliHLTUInt32_t gkAliHLTComponentInvalidShmType = 0; @@ -609,6 +978,18 @@ extern "C" { */ extern const AliHLTComponentDataType kAliHLTDataTypeDDL; + /** DAQ readout list + * @ingroup alihlt_component_datatypes + */ + extern const AliHLTComponentDataType kAliHLTDataTypeDAQRDOUT; + + /** CLUSTERS data + * Common data type for the output of cluster finders, the exact + * format depends on the origin (detector) + * @ingroup alihlt_component_datatypes + */ + extern const AliHLTComponentDataType kAliHLTDataTypeClusters; + /** SOR data type * @ingroup alihlt_component_datatypes */ @@ -619,11 +1000,23 @@ extern "C" { */ extern const AliHLTComponentDataType kAliHLTDataTypeEOR; + /** Run type data block + * @ingroup alihlt_component_datatypes + */ + extern const AliHLTComponentDataType kAliHLTDataTypeRunType; + /** Event type specification * @ingroup alihlt_component_datatypes */ extern const AliHLTComponentDataType kAliHLTDataTypeEvent; + /** ECS parameter event + * - sent during the SOR event by the framework + * - contains the full ECS parameter string + * @ingroup alihlt_component_datatypes + */ + extern const AliHLTComponentDataType kAliHLTDataTypeECSParam; // {ECSPARAM:PRIV} + /** Configuration event data type * @ingroup alihlt_component_datatypes */ @@ -639,13 +1032,32 @@ extern "C" { */ extern const AliHLTComponentDataType kAliHLTDataTypeDDLRaw; + /** AliMCEvent object data specification, origin is 'OFFL' + * @ingroup alihlt_component_datatypes + */ + extern const AliHLTComponentDataType kAliHLTDataTypeMCObject; + + /** ESD vertex object data specification, origin is 'any' + * @ingroup alihlt_component_datatypes + */ + extern const AliHLTComponentDataType kAliHLTDataTypeESDVertex; + + /** global vertexer data specification, origin is 'any' + * @ingroup alihlt_component_datatypes + */ + extern const AliHLTComponentDataType kAliHLTDataTypeGlobalVertexer; + /** ESD object data specification, origin is 'any' * @ingroup alihlt_component_datatypes */ extern const AliHLTComponentDataType kAliHLTDataTypeESDObject; + /** ESD content data specification, origin is 'any' + * @ingroup alihlt_component_datatypes + */ + extern const AliHLTComponentDataType kAliHLTDataTypeESDContent; + /** ESD Tree data specification, origin is 'any' - * @ingroup alihlt_component_datatypes */ extern const AliHLTComponentDataType kAliHLTDataTypeESDTree; @@ -680,11 +1092,49 @@ extern "C" { */ extern const AliHLTComponentDataType kAliHLTDataTypeRunStatistics; - /** Event summary + /** Run summary * @ingroup alihlt_component_datatypes */ extern const AliHLTComponentDataType kAliHLTDataTypeRunSummary; + /** Trigger decision + * - origin : kAliHLTDataOriginOut ( HLT ) + * @ingroup alihlt_component_datatypes + */ + extern const AliHLTComponentDataType kAliHLTDataTypeTriggerDecision; // {TRIG_DEC:HLT } + + /** Trigger decision + * - origin : kAliHLTDataOriginOut ( HLT ) + * @ingroup alihlt_component_datatypes + */ + extern const AliHLTComponentDataType kAliHLTDataTypeReadoutList; // {HLTRDLST:HLT } + + /** Global trigger decision + * - origin : kAliHLTDataOriginOut ( HLT ) + * @ingroup alihlt_component_datatypes + */ + extern const AliHLTComponentDataType kAliHLTDataTypeGlobalTrigger; // {GLOBTRIG:HLT } + + /** Component block statistics + * @ingroup alihlt_component_datatypes + */ + extern const AliHLTComponentDataType kAliHLTDataTypeComponentStatistics; + + /** Component table + * To be sent on SOR event, each component adds it's chain id string + * and a generated 32bit identifier to the table + * @ingroup alihlt_component_datatypes + */ + extern const AliHLTComponentDataType kAliHLTDataTypeComponentTable; + + /** Forwarded component table + * To be sent on SOR event, each component forwards blocks of type + * @ref kAliHLTDataTypeComponentTable was kAliHLTDataTypeComponentFwdTable + * after adding the parent ids to its own table struct. + * @ingroup alihlt_component_datatypes + */ + extern const AliHLTComponentDataType kAliHLTDataTypeComponentFwdTable; + ////////////////////////////////////////////////////////////////////////// // // Data Types for Monitoring objects @@ -695,6 +1145,11 @@ extern "C" { * @ingroup alihlt_component_datatypes */ extern const AliHLTComponentDataType kAliHLTDataTypeTObject; // {ROOTTOBJ,"***"} + + /** ROOT streamer info + * @ingroup alihlt_component_datatypes + */ + extern const AliHLTComponentDataType kAliHLTDataTypeStreamerInfo; // {ROOTSTRI,HLT } /** ROOT TObjArray * @ingroup alihlt_component_datatypes @@ -716,6 +1171,62 @@ extern "C" { */ extern const AliHLTComponentDataType kAliHLTDataTypeTNtuple; // {ROOTTUPL,"***"} + /** Global input trigger counters. + * - origin : kAliHLTDataOriginOut ( HLT ) + * @ingroup alihlt_component_datatypes + */ + extern const AliHLTComponentDataType kAliHLTDataTypeInputTriggerCounters; // {INTRGCNT:HLT } + + /** Global output trigger counters. + * - origin : kAliHLTDataOriginOut ( HLT ) + * @ingroup alihlt_component_datatypes + */ + extern const AliHLTComponentDataType kAliHLTDataTypeOutputTriggerCounters; // {OTTRGCNT:HLT } + + /** General track array for the barrel tracks based on AliExternalTrackParam + * Data format defined by AliHLTTracksData + * + * We follow the naming scheme of AliESDEvent where 'Tracks' denote the + * barrel tracks and detector tracks get names 'DETTracks' + * @ingroup alihlt_component_datatypes + */ + extern const AliHLTComponentDataType kAliHLTDataTypeTrack; // {HLTTRACK,"***"} + + /** Track Monte Carlo information + */ + extern const AliHLTComponentDataType kAliHLTDataTypeTrackMC; // {TRACK_MC,"***"} + + /** TClonesArray of AliExternalTrackParam + * @ingroup alihlt_component_datatypes + */ + extern const AliHLTComponentDataType kAliHLTDataTypeExternalTrackParam; // {TCAEXTTR,"***"} + + /** Container containing jets (AliHLTJETJets) + * Containing TClonesArray of AliAODJets + * @ingroup alihlt_component_datatypes + */ + extern const AliHLTComponentDataType kAliHLTDataTypeJet; // {HLTJETV0,"***"} + + /** Container of ITS tracks + * @ingroup alihlt_component_datatypes + */ + extern const AliHLTComponentDataType fgkITSTracksDataType; + + /** Container of calorimeter clusters + * @ingroup alihlt_component_datatypes + */ + extern const AliHLTComponentDataType kAliHLTDataTypeCaloCluster; + + /** Container of dEdx + * @ingroup alihlt_component_datatypes + */ + extern const AliHLTComponentDataType kAliHLTDataTypedEdx; + + /** Container of dNdPt + * @ingroup alihlt_component_datatypes + */ + extern const AliHLTComponentDataType kAliHLTDataTypedNdPt; + ////////////////////////////////////////////////////////////////////////// // // FXS subscriber meta information @@ -729,11 +1240,11 @@ extern "C" { /** Header in front of the data payload, in order to sent data to the FXS. */ struct AliHLTFXSHeader { - AliHLTUInt32_t fHeaderVersion; - AliHLTUInt32_t fRunNumber; - char fOrigin[gkAliHLTFXSHeaderfOriginSize]; - char fFileID[gkAliHLTFXSHeaderfFileIDSize]; - char fDDLNumber[gkAliHLTFXSHeaderfDDLNumberSize]; + AliHLTUInt32_t fHeaderVersion; /// HLT software version number. + AliHLTUInt32_t fRunNumber; /// The current run number. + char fOrigin[gkAliHLTFXSHeaderfOriginSize]; /// The detector from which the FXS data is received. + char fFileID[gkAliHLTFXSHeaderfFileIDSize]; /// File identifier for the stored data. + char fDDLNumber[gkAliHLTFXSHeaderfDDLNumberSize]; /// The DDL bits. }; ////////////////////////////////////////////////////////////////////////// @@ -742,6 +1253,9 @@ extern "C" { // ////////////////////////////////////////////////////////////////////////// + /** definition of a void fct pointer */ + typedef void (*AliHLTfctVoid)(); + /** logging function */ typedef int (*AliHLTfctLogging)( void* param, AliHLTComponentLogSeverity severity, @@ -750,24 +1264,118 @@ extern "C" { const char* message); /** - * @struct AliHLTComponentEnvironment + * @struct AliHLTAnalysisEnvironment * Running environment for analysis components. - * The struct describes function callbacks for + * The struct describes function callbacks for actions to be + * carried out by the calling framework, like memory allocation, + * property callbecks, logging, etc. + * + * @ingroup alihlt_wrapper_interface */ - struct AliHLTComponentEnvironment + struct AliHLTAnalysisEnvironment { + /** size of the structure */ AliHLTUInt32_t fStructSize; + + /** the component parameter given by the framework on creation */ void* fParam; + + /** allocated memory */ void* (*fAllocMemoryFunc)( void* param, unsigned long size ); + + /** allocate an EventDoneData structure. */ + int (*fGetEventDoneDataFunc)( void* param, AliHLTEventID_t eventID, unsigned long size, AliHLTComponentEventDoneData** edd ); + + /** logging callback */ + AliHLTfctLogging fLoggingFunc; + }; #if 0 - // future addition already foreseen/envisioned - // IMPORTANT: don not just remove the defines as this breaks the binary - // compatibility - int (*fAllocShmMemoryFunc)( void* param, unsigned long size, AliHLTComponentBlockData* blockLocation ); + // I just keep this as a note pad. Has to be added to the end of the structure + // future addition already foreseen/envisioned + // IMPORTANT: don not just remove the defines as this breaks the binary + // compatibility + int (*fAllocShmMemoryFunc)( void* param, unsigned long size, AliHLTComponentBlockData* blockLocation ); #endif + + /** + * @struct AliHLTComponentEnvironment + * This was the original definition of the running environment. + * Due to a bug in the AliRootWrapperSubscriber/SimpleComponentWrapper, + * this structure can not be used any longer but is kept for backward + * compatibility. + * @note The external interface provided by the libHLTbase is now kept + * frozen but should not be used any more. Use the interface provided + * by the libHLTinterface library. + * + * @ingroup alihlt_wrapper_interface_deprecated + */ + struct AliHLTComponentEnvironment + { + AliHLTUInt32_t fStructSize; + void* fParam; + void* (*fAllocMemoryFunc)( void* param, unsigned long size ); int (*fGetEventDoneDataFunc)( void* param, AliHLTEventID_t eventID, unsigned long size, AliHLTComponentEventDoneData** edd ); AliHLTfctLogging fLoggingFunc; }; + + ////////////////////////////////////////////////////////////////////////// + // + // The external interface definition + // + ////////////////////////////////////////////////////////////////////////// + + /** + * The component handle. + * Used as indification in the outside world. + * @ingroup alihlt_wrapper_interface + */ + typedef void* AliHLTComponentHandle; + + /** @ingroup alihlt_wrapper_interface */ + const AliHLTComponentHandle kEmptyHLTComponentHandle = 0; + + /** + * Get a system call of the interface. + * @param function signature + * @return pointer to system call + * @ingroup alihlt_wrapper_interface + */ + typedef void* (*AliHLTAnalysisFctGetInterfaceCall)(const char*); + +# define ALIHLTANALYSIS_INTERFACE_LIBRARY "libHLTinterface.so" +# define ALIHLTANALYSIS_FCT_GETINTERFACECALL "AliHLTAnalysisGetInterfaceCall" + + /** @ingroup alihlt_wrapper_interface */ + typedef int (*AliHLTExtFctInitSystem)( unsigned long version, AliHLTAnalysisEnvironment* externalEnv, unsigned long runNo, const char* runType ); + + /** @ingroup alihlt_wrapper_interface */ + typedef int (*AliHLTExtFctDeinitSystem)(); + + /** @ingroup alihlt_wrapper_interface */ + typedef int (*AliHLTExtFctLoadLibrary)( const char* ); + + /** @ingroup alihlt_wrapper_interface */ + typedef int (*AliHLTExtFctUnloadLibrary)( const char* ); + + /** @ingroup alihlt_wrapper_interface */ + typedef int (*AliHLTExtFctCreateComponent)( const char*, void*, int, const char**, AliHLTComponentHandle*, const char* description ); + + /** @ingroup alihlt_wrapper_interface */ + typedef int (*AliHLTExtFctDestroyComponent)( AliHLTComponentHandle ); + + /** @ingroup alihlt_wrapper_interface */ + typedef int (*AliHLTExtFctProcessEvent)( AliHLTComponentHandle, const AliHLTComponentEventData*, const AliHLTComponentBlockData*, + AliHLTComponentTriggerData*, AliHLTUInt8_t*, + AliHLTUInt32_t*, AliHLTUInt32_t*, + AliHLTComponentBlockData**, + AliHLTComponentEventDoneData** ); + + /** @ingroup alihlt_wrapper_interface */ + typedef int (*AliHLTExtFctGetOutputDataType)( AliHLTComponentHandle, AliHLTComponentDataType* ); + + /** @ingroup alihlt_wrapper_interface */ + typedef int (*AliHLTExtFctGetOutputSize)( AliHLTComponentHandle, unsigned long*, double* ); + } ////////////////////////////////////////////////////////////////////////// @@ -844,4 +1452,33 @@ inline AliHLTComponentDataType operator|(const AliHLTComponentDataType srcdt, co return dt; } +/** + * Helper function to initialize a data type from an id char array and origin string. + * @return data type structure initialized with the specified id and origin + * @ingroup alihlt_component_datatypes + */ +inline AliHLTComponentDataType AliHLTComponentDataTypeInitializer(const char id[kAliHLTComponentDataTypefIDsize], const char* origin) +{ + AliHLTComponentDataType dt=kAliHLTVoidDataType; + int i=0; + for (i = 0; i < kAliHLTComponentDataTypefIDsize && id[i]!=0; i++) + dt.fID[i]=id[i]; + for (i = 0; i < kAliHLTComponentDataTypefOriginSize && origin[i]!=0; i++ ) + dt.fOrigin[i]=origin[i]; + return dt; +} + +/** + * Helper function to initialize a data type from a default data type and + * an origin string. Basically it merges the specified origin into the data + * type. + * @return data type structure initialized with the id from specified data type + * and origin + * @ingroup alihlt_component_datatypes + */ +inline AliHLTComponentDataType AliHLTComponentDataTypeInitializer(const AliHLTComponentDataType src, const char* origin) +{ + return AliHLTComponentDataTypeInitializer(src.fID, origin); +} + #endif