f8c633b8fb41db3eb75aa75ee7acedb88854225c
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCEsdWriterComponent.h
1 // @(#) $Id$
2
3 #ifndef ALIHLTTPCESDWRITERCOMPONENT_H
4 #define ALIHLTTPCESDWRITERCOMPONENT_H
5 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
6  * See cxx source for full Copyright notice                               */
7
8 /** @file   AliHLTTPCEsdWriterComponent.h
9     @author Matthias Richter
10     @date   
11     @brief  Writer component to store tracks of the HLT TPC conformal
12             mapping tracker in the AliESD format
13
14                                                                           */
15 // see below for class documentation
16 // or
17 // refer to README to build package
18 // or
19 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
20
21 #include "AliHLTRootFileWriterComponent.h"
22 #include "AliHLTProcessor.h"
23
24 // forward declarations
25 class TTree;
26 class AliESDEvent;
27 class AliHLTTPCTrackArray;
28
29 /**
30  * @class AliHLTTPCEsdWriterComponent
31  * Translation of internal TPC track data to the ESD format.
32  * This class translates incoming track segments structures from the TPC
33  * conformal mapping tracker (datatype TRAKSEGS/TPC) or tracks in global 
34  * coordinates from the AliHLTTPCGlobalMergerComponent (TRACKS/TPC) into
35  * the ESD format.
36  *
37  * The \em TPCEsdWriter writes it to a ROOT file, the \em TPCEsdConverter
38  * to a TTree and sends the whole object to the output stream with data
39  * type ::kAliHLTDataTypeESDTree and origin TPC.
40  *
41  * In case of TRAKSEGS, the component can only process data block containing
42  * data of one slice, but it can read an unlimeted number of data blocks.
43  *
44  * componentid: \b TPCEsdWriter <br>
45  * componentid: \b TPCEsdConverter <br>
46  * componentlibrary: \b libAliHLTTPC.so <br>
47  * Arguments TPCEsdWriter: <br>
48  * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formating -->
49  * \li -datafile     <i> filename   </i> <br>
50  *      file name base
51  * \li -directory    <i> directory  </i> <br>
52  *      target directory
53  *
54  * Arguments TPCEsdConverter: <br>
55  * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formating -->
56  * \li -notree
57  *      write ESD directly to output (::kAliHLTDataTypeESDObject)
58  * \li -tree
59  *      write ESD directly to TTree and to output (::kAliHLTDataTypeESDTree),
60  *      this is the default behavior.
61  *
62  * <pre>
63  * Example usage (HLT configuration file):
64  *         \<Proc ID="EsdWriter" type="prc">
65  *             \<Cmd>AliRootWrapperSubscriber -eventmodulo 1
66  *                 -componentid TPCEsdWriter
67  *                 -componentlibrary libAliHLTTPC.so
68  *                 -componentargs "-datafile AliESDs.root"
69  *            \</Cmd>
70  *
71  *            \<Parent>TR0-SC\</Parent>
72  *            \<Node>master\</Node>
73  *            \<Shm blocksize="1k" blockcount="1" type="sysv"/>
74  *        \</Proc>
75  * </pre>
76  *
77  * @see AliHLTFileWriter and AliHLTRootFileWriterComponent for more parameters
78  *
79  * @ingroup alihlt_tpc_components
80  */
81 class AliHLTTPCEsdWriterComponent : public AliHLTLogging
82 {
83  public:
84   /** standard constructor */
85   AliHLTTPCEsdWriterComponent();
86   /** destructor */
87   ~AliHLTTPCEsdWriterComponent();
88
89   /**
90    * class AliHLTTPCEsdWriterComponent::AliWriter
91    * The writer component of the AliHLTTPCEsdWriterComponent.
92    */
93   class AliWriter : public AliHLTRootFileWriterComponent
94   {
95   public:
96   /** standard constructor */
97   AliWriter();
98   /** destructor */
99   virtual ~AliWriter();
100
101   /**
102    * The id of the component.
103    * @return component id (string)
104    */
105   const char* GetComponentID() {return "TPCEsdWriter";};
106
107   void GetInputDataTypes(AliHLTComponentDataTypeList& list);
108
109   /**
110    * Spawn function.
111    * @return new class instance
112    */
113   AliHLTComponent* Spawn() {return new AliHLTTPCEsdWriterComponent::AliWriter;}
114
115  protected:
116   /**
117    * Data processing method for the component.
118    * The function can be overloaded by specific ROOT file writer
119    * components.
120    * @param evtData       event data structure
121    * @param blocks        input data block descriptors
122    * @param trigData      trigger data structure
123    */
124   int DumpEvent( const AliHLTComponentEventData& evtData,
125                  const AliHLTComponentBlockData* blocks, 
126                  AliHLTComponentTriggerData& trigData );
127
128   using AliHLTRootFileWriterComponent::DumpEvent;
129
130   /**
131    * Scan one argument and adjacent parameters.
132    * @param argc           size of the argument array
133    * @param argv           agument array for component initialization
134    * @return number of processed members of the argv <br>
135    *         -EINVAL unknown argument <br>
136    *         -EPROTO parameter for argument missing <br>
137    */
138   int ScanArgument(int argc, const char** argv);
139  private:
140   /** copy constructor prohibited */
141   AliWriter(const AliWriter&);
142   /** assignment operator prohibited */
143   AliWriter& operator=(const AliWriter&);
144
145   /**
146    * Init the writer.
147    * The DoInit function is not available for this child class. InitWriter is the
148    * corresponding function for classes derived from AliHLTFileWriter.
149    */
150   int InitWriter();
151
152   /**
153    * Init the writer.
154    * The DoDeinit function is not available for this child class. CloseWriter is the
155    * corresponding function for classes derived from AliHLTFileWriter.
156    */
157   int CloseWriter();
158
159   /** the ESD tree */
160   TTree* fTree; //! transient value
161
162   /** the ESD */
163   AliESDEvent* fESD; //! transient value
164
165   /** pointer to the basic ESD conversion methods */
166   AliHLTTPCEsdWriterComponent* fBase; //! transient value
167   };
168
169   /**
170    * class AliHLTTPCEsdWriterComponent::AliConverter
171    * The converter component of the AliHLTTPCEsdWriterComponent.
172    * 
173    */
174   class AliConverter : public AliHLTProcessor
175   {
176   public:
177     /** standard constructor */
178     AliConverter();
179     /** destructor */
180     virtual ~AliConverter();
181
182     // interface methods of base class
183     const char* GetComponentID() {return "TPCEsdConverter";};
184     void GetInputDataTypes(AliHLTComponentDataTypeList& list);
185     AliHLTComponentDataType GetOutputDataType();
186     void GetOutputDataSize(unsigned long& constBase, double& inputMultiplier);
187     AliHLTComponent* Spawn() {return new AliHLTTPCEsdWriterComponent::AliConverter;}
188
189   protected:
190     // interface methods of base class
191     int DoInit(int argc, const char** argv);
192     int DoDeinit();
193     int DoEvent(const AliHLTComponentEventData& evtData,
194                 const AliHLTComponentBlockData* blocks, 
195                 AliHLTComponentTriggerData& trigData,
196                 AliHLTUInt8_t* outputPtr, 
197                 AliHLTUInt32_t& size,
198                 AliHLTComponentBlockDataList& outputBlocks );
199
200     using AliHLTProcessor::DoEvent;
201
202   private:
203     /** copy constructor prohibited */
204     AliConverter(const AliConverter&);
205     /** assignment operator prohibited */
206     AliConverter& operator=(const AliConverter&);
207
208     /** pointer to the basic ESD conversion methods */
209     AliHLTTPCEsdWriterComponent* fBase; //! transient value
210
211     /** write object to TTree or directly */
212     int fWriteTree; //!transient
213   };
214
215  protected:
216   /**
217    * Process the input data blocks.
218    * @param pTree    tree to be filled
219    * @param pESD     ESD to be filled
220    * @param blocks   data block descriptor array
221    * @param nBlocks  size of the array
222    * @param pMinSlice [OUT] receives the minimum slice no
223    * @param pMaxSlice [OUT] receives the maximum slice no
224    * @return neg. error code if failed
225    */
226   int ProcessBlocks(TTree* pTree, AliESDEvent* pESD, const AliHLTComponentBlockData* blocks,
227                     int nBlocks, int* pMinSlice=NULL, int* pMaxSlice=NULL);
228
229   /**
230    * Covert tracks to AliTPCtracks (AliKalmanTracks) and add them to ESD.
231    * @param pTracks  array of tracks
232    * @param pESD     pointer to ESD
233    * @return neg. error code if failed
234    */
235   int Tracks2ESD(AliHLTTPCTrackArray* pTracks, AliESDEvent* pESD);
236
237  private:
238   /** copy constructor prohibited */
239   AliHLTTPCEsdWriterComponent(const AliHLTTPCEsdWriterComponent&);
240   /** assignment operator prohibited */
241   AliHLTTPCEsdWriterComponent& operator=(const AliHLTTPCEsdWriterComponent&);
242
243   /**
244    * (Re)Configure from the CDB
245    * Loads the following objects:
246    * - HLT/ConfigHLT/SolenoidBz
247    */
248   int Reconfigure(const char* cdbEntry, const char* chainId);
249
250   /**
251    * Configure the component.
252    * Parse a string for the configuration arguments and set the component
253    * properties.
254    */  
255   int Configure(const char* arguments);
256
257   /** solenoid b field */
258   Double_t fSolenoidBz; //! transient
259
260   ClassDef(AliHLTTPCEsdWriterComponent, 2)
261 };
262 #endif