several bugfixes in the HLTOUT simulation
[u/mrichter/AliRoot.git] / HLT / sim / AliHLTSimulation.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   AliHLTSimulation.cxx
20     @author Matthias Richter
21     @date   
22     @brief  Binding class for HLT simulation in AliRoot. */
23
24 #include <cassert>
25 #include <cerrno>
26 #include "TObjArray.h"
27 #include "TObjString.h"
28 #include "AliHLTSimulation.h"
29 #include "AliLog.h"
30 #include "AliRunLoader.h"
31 #include "AliHLTSystem.h"
32 #include "AliRawReaderFile.h"
33 #include "AliRawReaderDate.h"
34 #include "AliRawReaderRoot.h"
35 #include "AliESDEvent.h"
36
37 #if ALIHLTSIMULATION_LIBRARY_VERSION != LIBHLTSIM_VERSION
38 #error library version in header file and lib*.pkg do not match
39 #endif
40
41 /** ROOT macro for the implementation of ROOT specific class methods */
42 ClassImp(AliHLTSimulation);
43
44 AliHLTSimulation::AliHLTSimulation()
45   :
46   fOptions(),
47   fpSystem(NULL),
48   fpRawReader(NULL)
49 {
50   // see header file for class documentation
51   // or
52   // refer to README to build package
53   // or
54   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
55 }
56
57 AliHLTSimulation::~AliHLTSimulation()
58 {
59   // see header file for function documentation
60   if (fpSystem) {
61     delete fpSystem;
62   }
63   fpSystem=NULL;
64   if (fpRawReader) {
65     delete fpRawReader;
66   }
67   fpRawReader=NULL;
68 }
69
70 AliHLTSimulation* AliHLTSimulation::CreateInstance()
71 {
72   // see header file for function documentation
73   return new AliHLTSimulation;
74 }
75
76 int AliHLTSimulation::DeleteInstance(AliHLTSimulation* pSim)
77 {
78   // see header file for function documentation
79   assert(pSim!=NULL);
80   delete pSim;
81   return 0;
82 }
83
84 int AliHLTSimulation::Init(AliRunLoader* pRunLoader, const char* options)
85 {
86   // init the simulation
87   fOptions=options;
88   TString sysOp;
89
90   if (!fpSystem) fpSystem=new AliHLTSystem;
91   if (!fpSystem) {
92     AliError("can not create AliHLTSystem object");
93     return -ENOMEM;
94   }
95   if (fpSystem->CheckStatus(AliHLTSystem::kError)) {
96     AliError("HLT system in error state");
97     return -EFAULT;
98   }
99
100   // scan options for specific entries
101   TObjArray* pTokens=fOptions.Tokenize(" ");
102   if (pTokens) {
103     int iEntries=pTokens->GetEntries();
104     for (int i=0; i<iEntries; i++) {
105       TString token=(((TObjString*)pTokens->At(i))->GetString());
106       if (token.Contains("rawfile=")) {
107         TString param=token.ReplaceAll("rawfile=", "");
108         if (param.EndsWith("/")) {
109           AliInfo(Form("creating AliRawReaderFile (%s)", param.Data()));
110           fpRawReader = new AliRawReaderFile(param);
111         } else if (param.EndsWith(".root")) {
112           AliInfo(Form("creating AliRawReaderRoot (%s)", param.Data()));
113           fpRawReader = new AliRawReaderRoot(param);
114         } else if (!param.IsNull()) {
115           AliInfo(Form("creating AliRawReaderDate (%s)", param.Data()));
116           fpRawReader = new AliRawReaderDate(param);
117           fpRawReader->SelectEvents(7);
118         }
119         if (fpRawReader) {
120             fpRawReader->RewindEvents();
121             int count=0;
122             for (; fpRawReader->NextEvent(); count++);
123             if (count!=pRunLoader->GetNumberOfEvents()) {
124               AliError(Form("missmatch in event count: runloader %d, rawreader %d; ignoring rawreader", 
125                             pRunLoader->GetNumberOfEvents(), count));
126               count=0;
127             }
128             if (count>0) {
129               fpRawReader->RewindEvents();
130               fpRawReader->NextEvent();
131             } else {
132               delete fpRawReader;
133               fpRawReader=NULL;
134             }
135         }
136       } else {
137         if (sysOp.Length()>0) sysOp+=" ";
138         sysOp+=token;
139       }
140     }
141     delete pTokens;
142   }
143
144   // scan options
145   if (fpSystem->ScanOptions(sysOp.Data())<0) {
146     AliError("error setting options for HLT system");
147     return -EINVAL;     
148   }
149
150   if (!fpSystem->CheckStatus(AliHLTSystem::kReady)) {
151     if ((fpSystem->Configure(pRunLoader))<0) {
152       AliError("error during HLT system configuration");
153       return -EFAULT;
154     }
155   }
156
157   return 0;
158 }
159
160
161 int AliHLTSimulation::Run(AliRunLoader* pRunLoader)
162 {
163   // HLT reconstruction for simulated data  
164   if(!pRunLoader) {
165     AliError("Missing RunLoader! 0x0");
166     return -EINVAL;
167   }
168
169   int nEvents = pRunLoader->GetNumberOfEvents();
170   int iResult=0;
171
172   if (fpSystem->CheckStatus(AliHLTSystem::kError)) {
173     AliError("HLT system in error state");
174     return -EFAULT;
175   }
176
177   // Note: the rawreader is already placed at the first event
178   if ((iResult=fpSystem->Reconstruct(1, pRunLoader, fpRawReader))>=0) {
179     fpSystem->FillESD(0, pRunLoader, NULL);
180     for (int i=1; i<nEvents; i++) {
181       if (fpRawReader && !fpRawReader->NextEvent()) {
182         AliError("missmatch in event count, rawreader corrupted");
183         break;
184       }
185       fpSystem->Reconstruct(1, pRunLoader, fpRawReader);
186       fpSystem->FillESD(i, pRunLoader, NULL);
187     }
188     // send specific 'event' to execute the stop sequence
189     fpSystem->Reconstruct(0, NULL, NULL);
190   }
191   return iResult;
192 }
193
194
195 AliHLTSimulation* AliHLTSimulationCreateInstance()
196 {
197   // see header file for function documentation
198   return AliHLTSimulation::CreateInstance();
199 }
200
201 int AliHLTSimulationDeleteInstance(AliHLTSimulation* pSim)
202 {
203   // see header file for function documentation
204   return AliHLTSimulation::DeleteInstance(pSim);
205 }
206
207 int AliHLTSimulationInit(AliHLTSimulation* pSim, AliRunLoader* pRunLoader, const char* options)
208 {
209   assert(pSim!=NULL);
210   if (pSim) {
211     return pSim->Init(pRunLoader, options);
212   }
213   return -ENODEV;
214 }
215
216 int AliHLTSimulationRun(AliHLTSimulation* pSim, AliRunLoader* pRunLoader)
217 {
218   assert(pSim!=NULL);
219   if (pSim) {
220     return pSim->Run(pRunLoader);
221   }
222   return -ENODEV;
223 }
224
225 int AliHLTSimulationGetLibraryVersion()
226 {
227   // see header file for function documentation
228   return LIBHLTSIM_VERSION;
229 }