When Pt is bad defined (ex. no field), the multiple scattering effect is calculated...
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCEsdWriterComponent.h
1 // @(#) $Id$
2
3 #ifndef ALIHLTTPCESDWRITERCOMPONENT_H
4 #define ALIHLTTPCESDWRITERCOMPONENT_H
5 //* This file is property of and copyright by the ALICE HLT Project        * 
6 //* ALICE Experiment at CERN, All rights reserved.                         *
7 //* See cxx source for full Copyright notice                               *
8
9 /** @file   AliHLTTPCEsdWriterComponent.h
10     @author Matthias Richter
11     @date   
12     @brief  Writer component to store tracks of the HLT TPC conformal
13             mapping tracker in the AliESD format
14 */
15
16 #include "AliHLTRootFileWriterComponent.h"
17 #include "AliHLTProcessor.h"
18
19 // forward declarations
20 class TTree;
21 class AliESDEvent;
22 class AliHLTTPCTrackArray;
23
24 /**
25  * @class AliHLTTPCEsdWriterComponent
26  * Translation of internal TPC track data to the ESD format.
27  * This class translates incoming track segments structures from the TPC
28  * conformal mapping tracker (datatype TRAKSEGS/TPC) or tracks in global 
29  * coordinates from the AliHLTTPCGlobalMergerComponent (TRACKS/TPC) into
30  * the ESD format.
31  *
32  * The \em TPCEsdWriter writes it to a ROOT file, the \em TPCEsdConverter
33  * to a TTree and sends the whole object to the output stream with data
34  * type ::kAliHLTDataTypeESDTree and origin TPC.
35  *
36  * In case of TRAKSEGS, the component can only process data block containing
37  * data of one slice, but it can read an unlimeted number of data blocks.
38  *
39  * componentid: \b TPCEsdWriter <br>
40  * componentid: \b TPCEsdConverter <br>
41  * componentlibrary: \b libAliHLTTPC.so <br>
42  * Arguments TPCEsdWriter: <br>
43  * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting -->
44  * \li -datafile     <i> filename   </i> <br>
45  *      file name base
46  * \li -directory    <i> directory  </i> <br>
47  *      target directory
48  *
49  * Arguments TPCEsdConverter: <br>
50  * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting -->
51  * \li -notree                                                          <br>
52  *      write ESD directly to output (::kAliHLTDataTypeESDObject)
53  *      this has been made the default behavior in Sep 2008.
54  * \li -tree                                                            <br>
55  *      write ESD directly to TTree and to output (::kAliHLTDataTypeESDTree)
56  * \li -solenoidBz                                                      <br>
57  *      magnetic field like -solenoidBz 5.0
58  *
59  * <pre>
60  * Example usage (HLT configuration file):
61  *         \<Proc ID="EsdWriter" type="prc">
62  *             \<Cmd>AliRootWrapperSubscriber -eventmodulo 1
63  *                 -componentid TPCEsdWriter
64  *                 -componentlibrary libAliHLTTPC.so
65  *                 -componentargs "-datafile AliESDs.root"
66  *            \</Cmd>
67  *
68  *            \<Parent>TR0-SC\</Parent>
69  *            \<Node>master\</Node>
70  *            \<Shm blocksize="1k" blockcount="1" type="sysv"/>
71  *        \</Proc>
72  * </pre>
73  *
74  * @see AliHLTFileWriter and AliHLTRootFileWriterComponent for more parameters
75  *
76  * @ingroup alihlt_tpc_components
77  */
78 class AliHLTTPCEsdWriterComponent : public AliHLTLogging
79 {
80  public:
81   /** standard constructor */
82   AliHLTTPCEsdWriterComponent();
83   /** destructor */
84   ~AliHLTTPCEsdWriterComponent();
85
86   /**
87    * class AliHLTTPCEsdWriterComponent::AliWriter
88    * The writer component of the AliHLTTPCEsdWriterComponent.
89    */
90   class AliWriter : public AliHLTRootFileWriterComponent
91   {
92   public:
93   /** standard constructor */
94   AliWriter();
95   /** destructor */
96   virtual ~AliWriter();
97
98   /**
99    * The id of the component.
100    * @return component id (string)
101    */
102   const char* GetComponentID() {return "TPCEsdWriter";};
103
104   void GetInputDataTypes(AliHLTComponentDataTypeList& list);
105
106   /**
107    * Spawn function.
108    * @return new class instance
109    */
110   AliHLTComponent* Spawn() {return new AliHLTTPCEsdWriterComponent::AliWriter;}
111
112  protected:
113   /**
114    * Data processing method for the component.
115    * The function can be overloaded by specific ROOT file writer
116    * components.
117    * @param evtData       event data structure
118    * @param blocks        input data block descriptors
119    * @param trigData      trigger data structure
120    */
121   int DumpEvent( const AliHLTComponentEventData& evtData,
122                  const AliHLTComponentBlockData* blocks, 
123                  AliHLTComponentTriggerData& trigData );
124
125   using AliHLTRootFileWriterComponent::DumpEvent;
126
127   /**
128    * Scan one argument and adjacent parameters.
129    * @param argc           size of the argument array
130    * @param argv           agument array for component initialization
131    * @return number of processed members of the argv <br>
132    *         -EINVAL unknown argument <br>
133    *         -EPROTO parameter for argument missing <br>
134    */
135   int ScanArgument(int argc, const char** argv);
136  private:
137   /** copy constructor prohibited */
138   AliWriter(const AliWriter&);
139   /** assignment operator prohibited */
140   AliWriter& operator=(const AliWriter&);
141
142   /**
143    * Init the writer.
144    * The DoInit function is not available for this child class. InitWriter is the
145    * corresponding function for classes derived from AliHLTFileWriter.
146    */
147   int InitWriter();
148
149   /**
150    * Init the writer.
151    * The DoDeinit function is not available for this child class. CloseWriter is the
152    * corresponding function for classes derived from AliHLTFileWriter.
153    */
154   int CloseWriter();
155
156   /** the ESD tree */
157   TTree* fTree; //! transient value
158
159   /** the ESD */
160   AliESDEvent* fESD; //! transient value
161
162   /** pointer to the basic ESD conversion methods */
163   AliHLTTPCEsdWriterComponent* fBase; //! transient value
164   };
165
166   /**
167    * class AliHLTTPCEsdWriterComponent::AliConverter
168    * The converter component of the AliHLTTPCEsdWriterComponent.
169    * 
170    */
171   class AliConverter : public AliHLTProcessor
172   {
173   public:
174     /** standard constructor */
175     AliConverter();
176     /** destructor */
177     virtual ~AliConverter();
178
179     // interface methods of base class
180     const char* GetComponentID() {return "TPCEsdConverter";};
181     void GetInputDataTypes(AliHLTComponentDataTypeList& list);
182     AliHLTComponentDataType GetOutputDataType();
183     void GetOutputDataSize(unsigned long& constBase, double& inputMultiplier);
184     AliHLTComponent* Spawn() {return new AliHLTTPCEsdWriterComponent::AliConverter;}
185
186   protected:
187     // interface methods of base class
188     int DoInit(int argc, const char** argv);
189     int DoDeinit();
190     int DoEvent(const AliHLTComponentEventData& evtData,
191                 const AliHLTComponentBlockData* blocks, 
192                 AliHLTComponentTriggerData& trigData,
193                 AliHLTUInt8_t* outputPtr, 
194                 AliHLTUInt32_t& size,
195                 AliHLTComponentBlockDataList& outputBlocks );
196
197     using AliHLTProcessor::DoEvent;
198
199   private:
200     /** copy constructor prohibited */
201     AliConverter(const AliConverter&);
202     /** assignment operator prohibited */
203     AliConverter& operator=(const AliConverter&);
204
205     /** the ESD */
206     AliESDEvent* fESD; //! transient value
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, 3)
261 };
262 #endif