- workaround for copying and merging of ESDs: The HLTOUT contains ESDs for every...
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCEsdWriterComponent.cxx
1 // @(#) $Id$
2
3 //**************************************************************************
4 //* This file is property of and copyright by the ALICE HLT Project        * 
5 //* ALICE Experiment at CERN, All rights reserved.                         *
6 //*                                                                        *
7 //* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
8 //*                  for The ALICE HLT Project.                            *
9 //*                                                                        *
10 //* Permission to use, copy, modify and distribute this software and its   *
11 //* documentation strictly for non-commercial purposes is hereby granted   *
12 //* without fee, provided that the above copyright notice appears in all   *
13 //* copies and that both the copyright notice and this permission notice   *
14 //* appear in the supporting documentation. The authors make no claims     *
15 //* about the suitability of this software for any purpose. It is          *
16 //* provided "as is" without express or implied warranty.                  *
17 //**************************************************************************
18
19 /** @file   AliHLTTPCEsdWriterComponent.cxx
20     @author Matthias Richter
21     @date   
22     @brief  Writer component to store tracks of the HLT TPC conformal
23             mapping tracker in the AliESD format
24 */
25
26 // see header file for class documentation
27 // or
28 // refer to README to build package
29 // or
30 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
31
32 #include <cassert>
33 #include "AliHLTTPCEsdWriterComponent.h"
34 #include "AliESDEvent.h"
35 #include "AliESDtrack.h"
36 #include "AliCDBEntry.h"
37 #include "AliCDBManager.h"
38 #include "TTree.h"
39 #include "TList.h"
40 #include "AliHLTTPCTrack.h"
41 #include "AliHLTTPCTrackArray.h"
42 #include "AliHLTTPCTrackletDataFormat.h"
43 #include "AliHLTTPCDefinitions.h"
44 #include "AliHLTTPCTransform.h"
45
46 /** ROOT macro for the implementation of ROOT specific class methods */
47 ClassImp(AliHLTTPCEsdWriterComponent)
48
49 AliHLTTPCEsdWriterComponent::AliHLTTPCEsdWriterComponent()
50   :
51   fSolenoidBz(0)
52 {
53   // see header file for class documentation
54   // or
55   // refer to README to build package
56   // or
57   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
58 }
59
60 AliHLTTPCEsdWriterComponent::~AliHLTTPCEsdWriterComponent()
61 {
62   // see header file for class documentation
63 }
64
65 AliHLTTPCEsdWriterComponent::AliWriter::AliWriter()
66   :
67   fTree(NULL),
68   fESD(NULL),
69   fBase(new AliHLTTPCEsdWriterComponent)
70 {
71   // see header file for class documentation
72   // or
73   // refer to README to build package
74   // or
75   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
76 }
77
78 AliHLTTPCEsdWriterComponent::AliWriter::~AliWriter()
79 {
80   // see header file for class documentation
81   if (fBase) delete fBase;
82   fBase=NULL;
83 }
84
85 void AliHLTTPCEsdWriterComponent::AliWriter::GetInputDataTypes(AliHLTComponentDataTypeList& list)
86 {
87   // see header file for class documentation
88   list.push_back(AliHLTTPCDefinitions::fgkTrackSegmentsDataType);
89   list.push_back(AliHLTTPCDefinitions::fgkTracksDataType);
90 }
91
92 int AliHLTTPCEsdWriterComponent::AliWriter::InitWriter()
93 {
94   // see header file for class documentation
95   int iResult=0;
96   fESD = new AliESDEvent;
97   if (fESD) {
98     fESD->CreateStdContent();
99     fTree = new TTree("esdTree", "Tree with HLT ESD objects");
100     if (fTree) {
101       fTree->SetDirectory(0);
102       fESD->WriteToTree(fTree);
103     }
104   }
105   if (fTree==NULL) {
106     iResult=-ENOMEM;
107   }
108
109   if (iResult>=0) {
110     iResult=fBase->Reconfigure(NULL, NULL);
111   }
112
113   return iResult;
114 }
115
116 int AliHLTTPCEsdWriterComponent::AliWriter::CloseWriter()
117 {
118   // see header file for class documentation
119   int iResult=0;
120   if (fTree) {
121     // the esd structure is written to the user info and is
122     // needed in te ReadFromTree method to read all objects correctly
123     if (fESD) fTree->GetUserInfo()->Add(fESD);
124     WriteObject(kAliHLTVoidEventID, fTree);
125     fTree->GetUserInfo()->Clear();
126     TTree* pTree=fTree;
127     fTree=NULL;
128     delete pTree;
129   } else {
130     HLTWarning("not initialized");
131   }
132
133   if (fESD) {
134     delete fESD;
135   }
136   iResult=AliHLTRootFileWriterComponent::CloseWriter();
137   return iResult;
138 }
139
140 int AliHLTTPCEsdWriterComponent::AliWriter::DumpEvent( const AliHLTComponentEventData& evtData,
141                                             const AliHLTComponentBlockData* blocks, 
142                                             AliHLTComponentTriggerData& /*trigData*/ )
143 {
144   // see header file for class documentation
145   int iResult=0;
146   TTree* pTree=fTree;
147   assert(fBase);
148   if (pTree && fBase) {
149     if (fESD) {
150       AliESDEvent* pESD=fESD;
151
152       iResult=fBase->ProcessBlocks(pTree, pESD, blocks, (int)evtData.fBlockCnt);
153
154     } else {
155       iResult=-ENOMEM;
156     }
157   }
158   return iResult;
159 }
160
161 int AliHLTTPCEsdWriterComponent::AliWriter::ScanArgument(int argc, const char** argv)
162 {
163   // see header file for class documentation
164   int iResult=AliHLTRootFileWriterComponent::ScanArgument(argc, argv);
165   return iResult;
166 }
167
168 int AliHLTTPCEsdWriterComponent::ProcessBlocks(TTree* pTree, AliESDEvent* pESD,
169                                                const AliHLTComponentBlockData* blocks,
170                                                int nBlocks, int* pMinSlice,
171                                                int* pMaxSlice)
172 {
173   // see header file for class documentation
174   int iResult=0;
175   if (pESD && blocks) {
176       pESD->SetMagneticField(fSolenoidBz);
177       const AliHLTComponentBlockData* iter = NULL;
178       AliHLTTPCTrackletData* inPtr=NULL;
179       int bIsTrackSegs=0;
180  
181       for (int ndx=0; ndx<nBlocks && iResult>=0; ndx++) {
182         iter = blocks+ndx;
183         if ( (bIsTrackSegs=(iter->fDataType == AliHLTTPCDefinitions::fgkTrackSegmentsDataType))==1 ||
184              iter->fDataType == AliHLTTPCDefinitions::fgkTracksDataType ) {
185           Int_t minslice=AliHLTTPCDefinitions::GetMinSliceNr(iter->fSpecification);
186           Int_t maxslice=AliHLTTPCDefinitions::GetMaxSliceNr(iter->fSpecification);
187           if (bIsTrackSegs==0) {
188             // slice parameter and data specification ignored, tracks already in global coordinates
189             minslice=-1;
190             maxslice=-1;
191             if (pMinSlice) *pMinSlice=0;
192             if (pMaxSlice) *pMaxSlice=AliHLTTPCTransform::GetNSlice()-1;
193           } else {
194             if (pMinSlice && (*pMinSlice==-1 || *pMinSlice>minslice)) *pMinSlice=minslice;
195             if (pMaxSlice && (*pMaxSlice==-1 || *pMaxSlice<maxslice)) *pMaxSlice=maxslice;
196           }
197           //HLTDebug("dataspec %#x minslice %d", iter->fSpecification, minslice);
198           if (minslice >=-1 && minslice<AliHLTTPCTransform::GetNSlice()) {
199             if (minslice!=maxslice) {
200               HLTWarning("data from multiple sectors in one block: "
201                          "possible mismatch in treatment of local coordinate system");
202             }
203             AliHLTTPCTrackArray tracks;
204             inPtr=(AliHLTTPCTrackletData*)iter->fPtr;
205             HLTDebug("reading block %d (slice %d): %d tracklets", ndx, minslice, inPtr->fTrackletCnt);
206             tracks.FillTracks(inPtr->fTrackletCnt, inPtr->fTracklets, minslice, 0/*don't rotate*/);
207             if ((iResult=Tracks2ESD(&tracks, pESD))>=0) {
208             }
209           } else {
210             HLTError("invalid sector number");
211             iResult=-EBADF;
212           }
213         }
214       }
215       if (iResult>=0 && pTree) {
216         pTree->Fill();
217       }
218
219       pESD->Reset();
220     
221   } else {
222     iResult=-EINVAL;
223   }
224   return iResult;
225 }
226
227 int AliHLTTPCEsdWriterComponent::Tracks2ESD(AliHLTTPCTrackArray* pTracks, AliESDEvent* pESD)
228 {
229   // see header file for class documentation
230   int iResult=0;
231   if (pTracks && pESD) {
232     HLTDebug("converting %d tracks from track array", pTracks->GetNTracks());
233     for (int i=0; i<pTracks->GetNTracks() && iResult>=0; i++) {
234       AliHLTTPCTrack* pTrack=(*pTracks)[i];
235       if (pTrack) {
236         //HLTDebug("convert track %d", i);
237         //pTrack->Print();
238         int iLocal=pTrack->Convert2AliKalmanTrack();
239         if (iLocal>=0) {
240         AliESDtrack iotrack;
241         iotrack.UpdateTrackParams(pTrack,AliESDtrack::kTPCin);
242         iotrack.SetTPCPoints(pTrack->GetPoints());
243         pESD->AddTrack(&iotrack);
244         } else {
245           HLTError("conversion to AliKalmanTrack failed for track %d of %d", i, pTracks->GetNTracks());
246         }
247       } else {
248         HLTError("internal mismatch in array");
249         iResult=-EFAULT;
250       }
251     }
252     
253   } else {
254     iResult=-EINVAL;
255   }
256   return iResult;
257 }
258
259 int AliHLTTPCEsdWriterComponent::Configure(const char* arguments)
260 {
261   // see header file for class documentation
262   int iResult=0;
263   if (!arguments) return iResult;
264
265   TString allArgs=arguments;
266   TString argument;
267   int bMissingParam=0;
268
269   TObjArray* pTokens=allArgs.Tokenize(" ");
270   if (pTokens) {
271     for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
272       argument=((TObjString*)pTokens->At(i))->GetString();
273       if (argument.IsNull()) continue;
274       
275       if (argument.CompareTo("-solenoidBz")==0) {
276         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
277         HLTInfo("Magnetic Field set to: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
278         fSolenoidBz=((TObjString*)pTokens->At(i))->GetString().Atof();
279         continue;
280       } else {
281         HLTError("unknown argument %s", argument.Data());
282         iResult=-EINVAL;
283         break;
284       }
285     }
286     delete pTokens;
287   }
288   if (bMissingParam) {
289     HLTError("missing parameter for argument %s", argument.Data());
290     iResult=-EINVAL;
291   }
292
293   return iResult;
294 }
295
296 int AliHLTTPCEsdWriterComponent::Reconfigure(const char* cdbEntry, const char* chainId)
297 {
298   // see header file for class documentation
299   int iResult=0;
300   const char* path="HLT/ConfigHLT/SolenoidBz";
301   const char* defaultNotify="";
302   if (cdbEntry) {
303     path=cdbEntry;
304     defaultNotify=" (default)";
305   }
306   if (path) {
307     HLTInfo("reconfigure from entry %s%s, chain id %s", path, defaultNotify,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
308     AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path/*,GetRunNo()*/);
309     if (pEntry) {
310       TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
311       if (pString) {
312         HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
313         iResult=Configure(pString->GetString().Data());
314       } else {
315         HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
316       }
317     } else {
318       HLTError("can not fetch object \"%s\" from CDB", path);
319     }
320   }
321   
322   return iResult;
323 }
324
325 AliHLTTPCEsdWriterComponent::AliConverter::AliConverter()
326   :
327   fBase(new AliHLTTPCEsdWriterComponent),
328   fWriteTree(1)
329 {
330   // see header file for class documentation
331   // or
332   // refer to README to build package
333   // or
334   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
335 }
336
337 AliHLTTPCEsdWriterComponent::AliConverter::~AliConverter()
338 {
339   // see header file for class documentation
340   if (fBase) delete fBase;
341   fBase=NULL;
342 }
343
344 void AliHLTTPCEsdWriterComponent::AliConverter::GetInputDataTypes(AliHLTComponentDataTypeList& list)
345 {
346   // see header file for class documentation
347   list.push_back(AliHLTTPCDefinitions::fgkTrackSegmentsDataType);
348   list.push_back(AliHLTTPCDefinitions::fgkTracksDataType);
349 }
350
351 AliHLTComponentDataType AliHLTTPCEsdWriterComponent::AliConverter::GetOutputDataType()
352 {
353   // see header file for class documentation
354   return kAliHLTDataTypeESDTree;
355 }
356
357 void AliHLTTPCEsdWriterComponent::AliConverter::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier)
358 {
359   // see header file for class documentation
360   constBase=2000000;
361   inputMultiplier=10.0;
362 }
363
364 int AliHLTTPCEsdWriterComponent::AliConverter::DoInit(int argc, const char** argv)
365 {
366   // see header file for class documentation
367   int iResult=0;
368   TString argument="";
369   int bMissingParam=0;
370   for (int i=0; i<argc && iResult>=0; i++) {
371     argument=argv[i];
372     if (argument.IsNull()) continue;
373
374     // -notree
375     if (argument.CompareTo("-notree")==0) {
376       fWriteTree=0;
377
378       // -tree
379     } else if (argument.CompareTo("-tree")==0) {
380       fWriteTree=1;
381
382     } else {
383       HLTError("unknown argument %s", argument.Data());
384       break;
385     }
386   }
387   if (bMissingParam) {
388     HLTError("missing parameter for argument %s", argument.Data());
389     iResult=-EINVAL;
390   }
391
392   if (iResult>=0) {
393     iResult=fBase->Reconfigure(NULL, NULL);
394   }
395
396   return iResult;
397 }
398
399 int AliHLTTPCEsdWriterComponent::AliConverter::DoDeinit()
400 {
401   // see header file for class documentation
402   return 0;
403 }
404
405 int AliHLTTPCEsdWriterComponent::AliConverter::DoEvent(const AliHLTComponentEventData& evtData, 
406                                                        const AliHLTComponentBlockData* blocks, 
407                                                        AliHLTComponentTriggerData& /*trigData*/,
408                                                        AliHLTUInt8_t* /*outputPtr*/, 
409                                                        AliHLTUInt32_t& /*size*/,
410                                                        AliHLTComponentBlockDataList& /*outputBlocks*/ )
411 {
412   // see header file for class documentation
413   int iResult=0;
414   assert(fBase);
415   AliESDEvent* pESD = new AliESDEvent;
416   if (pESD && fBase) {
417     pESD->CreateStdContent();
418     TTree* pTree = NULL;
419     // TODO: Matthias 06.12.2007
420     // Tried to write the ESD directly instead to a tree, but this did not work
421     // out. Information in the ESD is different, needs investigation.
422     if (fWriteTree)
423       pTree = new TTree("esdTree", "Tree with HLT ESD objects");
424     if (pTree) {
425       pTree->SetDirectory(0);
426       pESD->WriteToTree(pTree);
427     }
428
429     if ((iResult=fBase->ProcessBlocks(pTree, pESD, blocks, (int)evtData.fBlockCnt))>=0) {
430         // TODO: set the specification correctly
431       if (pTree) {
432         // the esd structure is written to the user info and is
433         // needed in te ReadFromTree method to read all objects correctly
434         pTree->GetUserInfo()->Add(pESD);
435         iResult=PushBack(pTree, kAliHLTDataTypeESDTree|kAliHLTDataOriginTPC, 0);
436       } else {
437         iResult=PushBack(pESD, kAliHLTDataTypeESDObject|kAliHLTDataOriginTPC, 0);
438       }
439     }
440     if (pTree) {
441       // clear user info list to prevent objects from being deleted
442       pTree->GetUserInfo()->Clear();
443       delete pTree;
444     }
445
446     delete pESD;
447   }
448   return iResult;
449 }
450