]>
Commit | Line | Data |
---|---|---|
ce5f90bf | 1 | //-*- Mode: C++ -*- |
2 | // $Id$ | |
3 | ||
4 | #ifndef ALIHLTBENCHEXTERNALTRACKCOMPONENT_H | |
5 | #define ALIHLTBENCHEXTERNALTRACKCOMPONENT_H | |
6 | //* This file is property of and copyright by the ALICE HLT Project * | |
7 | //* ALICE Experiment at CERN, All rights reserved. * | |
8 | //* See cxx source for full Copyright notice * | |
9 | ||
10 | /** @file AliHLTBenchExternalTrackComponent.h | |
11 | @author Matthias Richter | |
12 | @date 2008-10-30 | |
13 | @brief Benchmark component for AliExternalTrackParam transportation. | |
14 | */ | |
15 | ||
16 | // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt | |
17 | ||
18 | #include "AliHLTProcessor.h" | |
19 | ||
20 | class AliExternalTrackParam; | |
21 | class AliHLTExternalTrackParam; | |
22 | class TClonesArray; | |
23 | class TObjArray; | |
24 | class TRandom; | |
25 | class TList; | |
26 | ||
27 | /** | |
28 | * @class AliHLTBenchExternalTrackComponent | |
29 | * A component publishing arrays of randomly filled AliExternalTrackParam | |
30 | * structures in different forms. Currently supported is TClonesArray, | |
31 | * TObjArray, and C Array. | |
32 | * | |
33 | * The component can both publish and receive data blocks. If data blocks | |
34 | * are available on the input, the array is restored and forwarded in the | |
35 | * specified publishing mode with specified compression level. | |
36 | * | |
37 | * <h2>General properties:</h2> | |
38 | * | |
39 | * Component ID: \b BenchmarkAliExternalTrackParam <br> | |
40 | * Library: \b libAliHLTBenchmark.so <br> | |
41 | * Input Data Types: ::kAliHLTDataTypeTrack, ::kAliHLTDataTypeTObjArray <br> | |
42 | * Output Data Types: ::kAliHLTDataTypeTrack, ::kAliHLTDataTypeTObjArray <br> | |
43 | * | |
44 | * <h2>Mandatory arguments:</h2> | |
45 | * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting --> | |
46 | * By default, publishing of the array is switched off. It has to be enabled | |
47 | * by one of the three options | |
48 | * \li -tobjarray <br> | |
49 | * publish TObjArray | |
50 | * \li -tclonesarray <br> | |
51 | * publish TClonesArray | |
52 | * \li -carray <br> | |
53 | * publish as C-array | |
54 | * | |
55 | * <h2>Optional arguments:</h2> | |
56 | * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting --> | |
57 | * \li -maxsize <i> max array size </i> <br> | |
58 | * \li -minsize <i> min array size </i> <br> | |
59 | * | |
60 | * \li -rangemodulo <i> count </i> <br> | |
61 | * number of events after which the range is changed | |
62 | * \li -rangeoffset <i> offset </i> <br> | |
63 | * offset is added to min and max range after the specified number of | |
64 | * events. Idially, this offset is negative, causing decreasing range | |
65 | * over run time. | |
66 | * \li -rangefactor <i> factor </i> <br> | |
67 | * min and max range are multiplied by the factor (float) after the | |
68 | * specified number of events. | |
69 | * | |
70 | * \li -verbosity <i> level </i> <br> | |
71 | * different levels of verbosity: 0 (default) is silent | |
72 | * | |
73 | * <h2>Configuration:</h2> | |
74 | * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting --> | |
75 | * | |
76 | * <h2>Default CDB entries:</h2> | |
77 | * The component has no default CDB entries. | |
78 | * | |
79 | * <h2>Performance:</h2> | |
80 | * | |
81 | * | |
82 | * <h2>Memory consumption:</h2> | |
83 | * | |
84 | * | |
85 | * <h2>Output size:</h2> | |
86 | * | |
87 | * | |
88 | * By using the range alterator options, the range can be changed after a | |
89 | * certain number of events. | |
90 | * | |
91 | * @ingroup alihlt_benchmark_components | |
92 | */ | |
93 | class AliHLTBenchExternalTrackComponent : public AliHLTProcessor { | |
94 | public: | |
95 | /** default constructor */ | |
96 | AliHLTBenchExternalTrackComponent(); | |
97 | /** destructor */ | |
98 | virtual ~AliHLTBenchExternalTrackComponent(); | |
99 | ||
100 | // interface functions: property getters | |
101 | const char* GetComponentID(); | |
102 | void GetInputDataTypes(AliHLTComponentDataTypeList& list); | |
103 | AliHLTComponentDataType GetOutputDataType(); | |
104 | int GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList); | |
105 | void GetOutputDataSize(unsigned long& constBase, double& inputMultiplier); | |
106 | AliHLTComponent* Spawn(); | |
107 | ||
108 | /** | |
109 | * Fill members of the track object with random float values. | |
110 | * @param track reference to AliExternalTrackParam object | |
111 | * @param fillCov number of elements of the covar members to be filled | |
112 | * max 15 | |
113 | */ | |
114 | static int FillRandom(AliExternalTrackParam* track, int fillCov=15); | |
115 | ||
116 | /** | |
117 | * Serialize an object or clones array of AliExternalTrackParam objects | |
118 | * to a buffer using the definition AliHLTExternalTrackParam. | |
119 | * @param pArray the array | |
120 | * @param buffer target buffer | |
121 | * @param size buffer size | |
122 | * @return bytes filled to the buffer, neg. error code if failed | |
123 | */ | |
124 | static int SerializeToStruct(const TObjArray* pArray, AliHLTUInt8_t* buffer, unsigned int size); | |
125 | ||
126 | /** | |
127 | * Translate AliHLTExternalTrackParam struct into objects. | |
128 | * The TObjArray can also be a TClonesArray and must have enough capacity. | |
129 | */ | |
130 | static int ReadFromStruct(TObjArray* pTgtArray, AliHLTExternalTrackParam* pArray, unsigned int arraySize); | |
131 | ||
132 | /** | |
133 | * Calculate a crc checksum for the object array | |
134 | */ | |
135 | static AliHLTUInt32_t CalcChecksum(const TObjArray* pArray); | |
136 | ||
137 | /** | |
138 | * Compare two arrays of AliExternalTrackParamElements | |
139 | */ | |
140 | static bool Compare(const TObjArray* array1, const TObjArray* array2); | |
141 | ||
142 | /** | |
143 | * Find object in the registry | |
144 | */ | |
145 | static TObject* FindObject(AliHLTUInt32_t id); | |
146 | ||
147 | enum { | |
148 | kPublishingOff = 0, | |
149 | ktobjarray = 1, | |
150 | ktclonesarray, | |
151 | kcarray, | |
152 | }; | |
153 | ||
154 | protected: | |
155 | // interface functions: processing | |
156 | int DoInit(int argc, const char** argv); | |
157 | int DoDeinit(); | |
158 | int DoEvent( const AliHLTComponentEventData& evtData, | |
159 | const AliHLTComponentBlockData* blocks, | |
160 | AliHLTComponentTriggerData& trigData, | |
161 | AliHLTUInt8_t* outputPtr, | |
162 | AliHLTUInt32_t& size, | |
163 | AliHLTComponentBlockDataList& outputBlocks ); | |
164 | ||
165 | /** | |
166 | * Register object and create reference id | |
167 | * The registry is used for consistency checks in a single threaded system. | |
168 | * The dump component can access the original object and compare the two. | |
169 | */ | |
170 | AliHLTUInt32_t Register(TObject* pObject); | |
171 | ||
172 | /** | |
173 | * Remove object from registry | |
174 | */ | |
175 | int Unregister(TObject* pObject); | |
176 | ||
177 | private: | |
178 | /** copy constructor prohibited */ | |
179 | AliHLTBenchExternalTrackComponent(const AliHLTBenchExternalTrackComponent&); | |
180 | /** assignment operator prohibited */ | |
181 | AliHLTBenchExternalTrackComponent& operator=(const AliHLTBenchExternalTrackComponent&); | |
182 | ||
183 | /** verbosity */ | |
184 | int fVerbosity; //!transient | |
185 | ||
186 | /** disable global object registry, no check pf received objects */ | |
187 | bool fDisableRegistry; //! transient | |
188 | ||
189 | /** publishing mode: off, ktclonesarray, ktobjarray, kcarray */ | |
190 | int fMode; //! transient | |
191 | ||
192 | /** maximum array size */ | |
193 | int fMaxSize; //! transient | |
194 | ||
195 | /** minimum array size */ | |
196 | int fMinSize; //! transient | |
197 | ||
198 | /** event count for the next automatic change of range */ | |
199 | int fEventModulo; | |
200 | ||
201 | /** offset is added to range after fEventModulo events */ | |
202 | int fRangeOffset; | |
203 | ||
204 | /** range is multiplied after fEventModulo events */ | |
205 | float fRangeMultiplicator; | |
206 | ||
207 | /** the internal array */ | |
208 | TClonesArray* fpTcArray; //! transient | |
209 | ||
210 | /** TObjArray this publishing mode was used */ | |
211 | TObjArray* fpTObjArray; //! transient | |
212 | ||
213 | /** random number generator */ | |
214 | TRandom* fpDice; //! transient | |
215 | ||
216 | /** registry of object arrays */ | |
217 | static TList* fgpRegistry; //! transient | |
218 | ||
219 | ClassDef(AliHLTBenchExternalTrackComponent, 0); | |
220 | }; | |
221 | ||
222 | #endif |