Line data Source code
1 : //-*- Mode: C++ -*-
2 : // $Id$
3 :
4 : #ifndef ALIHLTOUTCOMPONENT_H
5 : #define ALIHLTOUTCOMPONENT_H
6 : //* This file is property of and copyright by the *
7 : //* ALICE Experiment at CERN, All rights reserved. *
8 : //* See cxx source for full Copyright notice *
9 :
10 : /// @file AliHLTOUTComponent.h
11 : /// @author Matthias Richter
12 : /// @date
13 : /// @brief The HLTOUT data sink component similar to HLTOUT nodes.
14 : /// @note Used in the AliRoot environment only.
15 :
16 : #include "AliHLTDataSink.h"
17 :
18 : class AliHLTHOMERLibManager;
19 : class AliHLTMonitoringWriter;
20 : class TFile;
21 : class TTree;
22 : typedef vector<AliHLTMonitoringWriter*> AliHLTMonitoringWriterPVector;
23 :
24 : /**
25 : * @class AliHLTOUTComponent
26 : * The HLTOUT data sink component which models the behavior of the HLTOUT
27 : * nodes of the HLT cluster.
28 : * <h2>General properties:</h2>
29 : * The HLTOUT component is attached at the end of a chain. It stores all input
30 : * block in the HOMER format, distributed over a number of DDL link. The data
31 : * is stored in a digit file or in raw ddl files.
32 : *
33 : * Component ID: \b HLTOUT <br>
34 : * Library: \b libHLTrec.so <br>
35 : * Input Data Types: @ref kAliHLTAnyDataType <br>
36 : * Output Data Types: none (offline data sink) <br>
37 : *
38 : * <h2>Mandatory arguments:</h2>
39 : * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting -->
40 : *
41 : * <h2>Optional arguments:</h2>
42 : * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting -->
43 : * \li -links <i> n </i> <br>
44 : * number of output ddl links
45 : * \li -digitfile <i> name </i> <br>
46 : * name of the digit file to write (default HLT.Digits.root)
47 : * \li -rawout[=on,off] <br>
48 : * switch raw output on/off (default on)
49 : * \li -digitout[=on,off] <br>
50 : * switch digit output on/off (default on)
51 : *
52 : * <h2>Configuration:</h2>
53 : * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting -->
54 : * none
55 : *
56 : * <h2>Default CDB entries:</h2>
57 : * none
58 : *
59 : * <h2>Performance:</h2>
60 : * The component does not any event data processing.
61 : *
62 : * <h2>Memory consumption:</h2>
63 : * The component does not any event data processing.
64 : *
65 : * <h2>Output size:</h2>
66 : * The component is an offline sink component and has no output data.
67 : *
68 : * The component can be used to write data in the same format as
69 : * the HLTOUT on the real HLT. In case of AliRoot simulation, the
70 : * component is automatically added to the chain if the specified
71 : * chains have output data. By that means, the HLT output is added
72 : * to the simulation.
73 : *
74 : * @ingroup alihlt_aliroot_simulation
75 : */
76 : class AliHLTOUTComponent : public AliHLTDataSink {
77 : public:
78 : /// type of the HLTOUT component
79 : enum EType {
80 : kGlobal = 0, // generate according to global flags
81 : kDigits = 1, // generate only digits: ID HLTOUTdigits
82 : kRaw = 2 // generate only raw: ID HLTOUTraw
83 : };
84 : /// constructor for different component types
85 : AliHLTOUTComponent(EType type=kGlobal);
86 : /** destructor */
87 : virtual ~AliHLTOUTComponent();
88 :
89 : const char* GetComponentID();
90 : void GetInputDataTypes( AliHLTComponentDataTypeList& list);
91 : AliHLTComponent* Spawn();
92 :
93 : /**
94 : * Enable global options valid for all instances of the component
95 : * @param options bit field
96 : */
97 : static void SetGlobalOption(unsigned int options);
98 :
99 : /**
100 : * Disable global options valid for all instances of the component
101 : * @param options bit field
102 : */
103 : static void ClearGlobalOption(unsigned int options);
104 :
105 : /**
106 : * Test one of the global options
107 : */
108 : static bool TestGlobalOption(unsigned int option);
109 :
110 : enum {
111 : /** write the raw files of the HLT links */
112 : kWriteRawFiles = 0x1,
113 : /** write the digit file */
114 : kWriteDigits = 0x2
115 : };
116 :
117 : protected:
118 : /**
119 : * Init method.
120 : */
121 : int DoInit( int argc, const char** argv );
122 :
123 : /// inherited from AliHLTComponent, component specific argument scan
124 : int ScanConfigurationArgument(int argc, const char** argv);
125 :
126 : /**
127 : * Deinit method.
128 : */
129 : int DoDeinit();
130 :
131 : /**
132 : * Data processing method for the component.
133 : * The function can be overloaded by other file writer components.
134 : * @param evtData event data structure
135 : * @param blocks input data block descriptors
136 : * @param trigData trigger data structure
137 : */
138 : int DumpEvent( const AliHLTComponentEventData& evtData,
139 : const AliHLTComponentBlockData* blocks,
140 : AliHLTComponentTriggerData& trigData );
141 :
142 : using AliHLTDataSink::DumpEvent;
143 :
144 : /**
145 : * Write the ecoded HLTOUT data to raw and digits files.
146 : * Originally data was written in the FillESD function of the
147 : * AliHLTOfflineInterface. Mainly for the sake of availability of the
148 : * AliLoader. This concept has not turned out to be succesful and the
149 : * development went a slightly different direction with the concept of
150 : * HLTOUT handlers.
151 : * 2010-04-14 change the original FillESD() to Write(), keep the body
152 : * of the function
153 : *
154 : * @param eventNo event No. \em Note: this is an internal enumeration of the
155 : * processed events.
156 : * @param runLoader the AliRoot runloader
157 : * @return neg. error code if failed
158 : */
159 : int Write(int eventNo);
160 :
161 : private:
162 : /** copy constructor prohibited */
163 : AliHLTOUTComponent(const AliHLTOUTComponent&);
164 : /** assignment operator prohibited */
165 : AliHLTOUTComponent& operator=(const AliHLTOUTComponent&);
166 :
167 : int ShuffleWriters(AliHLTMonitoringWriterPVector &list, AliHLTUInt32_t size);
168 :
169 : /**
170 : * Fill the output buffer and allocate if neccessary.
171 : * Assemble ouput buffer with Common Data Header, HLT header and data from the
172 : * writer. Works on the same buffer witch is allocated once and eventually
173 : * grown in order to avoid frequent allocs/deallocs.
174 : * @param eventNo number of the event
175 : * @param pWriter [IN] the HOMER writer
176 : * @param pBuffer [OUT] target to receive the pointer to buffer
177 : * @return size of the buffer
178 : */
179 : int FillOutputBuffer(int eventNo, AliHLTMonitoringWriter* pWriter, const AliHLTUInt8_t* &pBuffer);
180 :
181 : /**
182 : * Write data for a DDL link.
183 : * @param hltddl Number of DDL link within the range of HLT
184 : * @param pBuffer buffer to write
185 : * @param bufferSize size of the buffer
186 : */
187 : int WriteDigitArray(int hltddl, const AliHLTUInt8_t* pBuffer, unsigned int bufferSize);
188 :
189 : /**
190 : * Write the digits for one DDL
191 : * @param eventNo number of the event
192 : * @return neg. error if failed
193 : */
194 : int WriteDigits(int eventNo);
195 :
196 : /**
197 : * Write the raw file for one DDL
198 : * @param eventNo number of the event
199 : * @param hltddl Number of DDL link within the range of HLT
200 : * @param pBuffer buffer to write
201 : * @param size size of the buffer
202 : * @return neg. error if failed
203 : */
204 : int WriteRawFile(int eventNo, int hltddl, const AliHLTUInt8_t* pBuffer, unsigned int size);
205 :
206 : /** list of HOMER writers */
207 : AliHLTMonitoringWriterPVector fWriters; //!transient
208 :
209 : /** number of DDLs used*/
210 : int fNofDDLs; //!transient
211 :
212 : /** equipment ID of first HLT DDL */
213 : int fIdFirstDDL; //!transient
214 :
215 : /** output buffer, allocated once in order to avoid frequent alloc/dealloc */
216 : vector<AliHLTUInt8_t> fBuffer; //!transient
217 :
218 : /** instance of the HOMER library manager */
219 : AliHLTHOMERLibManager* fpLibManager; // !transient
220 :
221 : /** global options for all instances */
222 : static int fgOptions; //! transient
223 :
224 : /// component options set from component type or global options at DoInit
225 : int fOptions; //! transient
226 :
227 : /** digit file name */
228 : TString fDigitFileName; //! transient
229 :
230 : /** the root file for the HLT 'digit' output */
231 : TFile* fpDigitFile; //!transient
232 :
233 : /** the tree for the HLT 'digit' output */
234 : TTree* fpDigitTree; //!transient
235 :
236 : /** array of TArrayC output buffers and branches */
237 : TArrayC** fppDigitArrays; //!transient
238 :
239 : /** Id of HOMER writer kept from previous event */
240 : int fReservedWriter; //!transient
241 :
242 : /** Data size kept in the internal buffer */
243 : int fReservedData; //!transient
244 :
245 : /// type of the component
246 : EType fType; //! type of the component
247 :
248 : /// counter for round robin usage of HLTOUT links
249 : int fRoundRobinCounter; //! counter for round robin usage of HLTOUT links
250 :
251 126 : ClassDef(AliHLTOUTComponent, 0)
252 : };
253 : #endif
|
