- handling of global AliHLTSystem singleton moved to BASE
[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   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 (fpRawReader) {
61     delete fpRawReader;
62   }
63   fpRawReader=NULL;
64 }
65
66 AliHLTSimulation* AliHLTSimulation::CreateInstance()
67 {
68   // see header file for function documentation
69   return new AliHLTSimulation;
70 }
71
72 int AliHLTSimulation::DeleteInstance(AliHLTSimulation* pSim)
73 {
74   // see header file for function documentation
75   assert(pSim!=NULL);
76   delete pSim;
77   return 0;
78 }
79
80 int AliHLTSimulation::Init(AliRunLoader* pRunLoader, const char* options)
81 {
82   // init the simulation
83   fOptions=options;
84   TString sysOp;
85
86   AliHLTSystem* pSystem=GetInstance();
87   if (!pSystem) {
88     AliError("can not get AliHLTSystem instance");
89     return -ENOMEM;
90   }
91   if (pSystem->CheckStatus(AliHLTSystem::kError)) {
92     AliError("HLT system in error state");
93     return -EFAULT;
94   }
95
96   // scan options for specific entries
97   TObjArray* pTokens=fOptions.Tokenize(" ");
98   if (pTokens) {
99     int iEntries=pTokens->GetEntries();
100     for (int i=0; i<iEntries; i++) {
101       TString token=(((TObjString*)pTokens->At(i))->GetString());
102       if (token.Contains("rawfile=")) {
103         TString param=token.ReplaceAll("rawfile=", "");
104         if (param.EndsWith("/")) {
105           AliInfo(Form("creating AliRawReaderFile (%s)", param.Data()));
106           fpRawReader = new AliRawReaderFile(param);
107         } else if (param.EndsWith(".root")) {
108           AliInfo(Form("creating AliRawReaderRoot (%s)", param.Data()));
109           fpRawReader = new AliRawReaderRoot(param);
110         } else if (!param.IsNull()) {
111           AliInfo(Form("creating AliRawReaderDate (%s)", param.Data()));
112           fpRawReader = new AliRawReaderDate(param);
113           fpRawReader->SelectEvents(7);
114         }
115         if (fpRawReader) {
116             fpRawReader->RewindEvents();
117             int count=0;
118             for (; fpRawReader->NextEvent(); count++);
119             if (count!=pRunLoader->GetNumberOfEvents()) {
120               AliError(Form("missmatch in event count: runloader %d, rawreader %d; ignoring rawreader", 
121                             pRunLoader->GetNumberOfEvents(), count));
122               count=0;
123             }
124             if (count>0) {
125               fpRawReader->RewindEvents();
126               fpRawReader->NextEvent();
127             } else {
128               delete fpRawReader;
129               fpRawReader=NULL;
130             }
131         }
132       } else if (token.Contains("writerawfiles=")) {
133         if (!token.ReplaceAll("writerawfiles=", "").Contains("HLT")) {
134           AliHLTOUTComponent::ClearGlobalOption(AliHLTOUTComponent::kWriteRawFiles);
135         }
136       } else {
137         if (sysOp.Length()>0) sysOp+=" ";
138         sysOp+=token;
139       }
140     }
141     delete pTokens;
142   }
143
144   // scan options
145   if (pSystem->ScanOptions(sysOp.Data())<0) {
146     AliError("error setting options for HLT system");
147     return -EINVAL;     
148   }
149
150   if (!pSystem->CheckStatus(AliHLTSystem::kReady)) {
151     if ((pSystem->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   AliHLTSystem* pSystem=GetInstance();
173   if (!pSystem) {
174     AliError("can not get AliHLTSystem instance");
175     return -ENOMEM;
176   }
177   if (pSystem->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=pSystem->Reconstruct(1, pRunLoader, fpRawReader))>=0) {
184     pSystem->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       pSystem->Reconstruct(1, pRunLoader, fpRawReader);
191       pSystem->FillESD(i, pRunLoader, NULL);
192     }
193     // send specific 'event' to execute the stop sequence
194     pSystem->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 }