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