45359cdca4cedc5ea7f1dcb15ca3057530b77779
[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 "AliSimulation.h"
30 #include "AliLog.h"
31 #include "AliRun.h"
32 #include "AliRunLoader.h"
33 #include "AliHeader.h"
34 #include "AliCDBManager.h"
35 #include "AliCDBEntry.h"
36 #include "AliCDBPath.h"
37 #include "AliCDBId.h"
38 #include "AliCDBMetaData.h"
39 #include "AliCDBStorage.h"
40 #include "AliGRPObject.h"
41 #include "AliGRPManager.h"
42 #include "AliHLTSystem.h"
43 #include "AliHLTPluginBase.h"
44 #include "AliRawReaderFile.h"
45 #include "AliRawReaderDate.h"
46 #include "AliRawReaderRoot.h"
47 #include "AliESDEvent.h"
48 #include "AliHLTOUTComponent.h"
49 #include "AliTracker.h"
50 #include "TGeoGlobalMagField.h"
51 #include "TSystem.h"
52 #include "TMath.h"
53 #include "TGeoGlobalMagField.h"
54
55 #if ALIHLTSIMULATION_LIBRARY_VERSION != LIBHLTSIM_VERSION
56 #error library version in header file and lib*.pkg do not match
57 #endif
58
59 /** ROOT macro for the implementation of ROOT specific class methods */
60 ClassImp(AliHLTSimulation);
61
62 AliHLTSimulation::AliHLTSimulation()
63   :
64   fOptions(),
65   fpPluginBase(new AliHLTPluginBase),
66   fpRawReader(NULL)
67 {
68   // see header file for class documentation
69   // or
70   // refer to README to build package
71   // or
72   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
73 }
74
75 AliHLTSimulation::~AliHLTSimulation()
76 {
77   // see header file for function documentation
78   if (fpPluginBase) delete fpPluginBase;
79   fpPluginBase=NULL;
80
81   if (fpRawReader) {
82     delete fpRawReader;
83   }
84   fpRawReader=NULL;
85 }
86
87 AliHLTSimulation* AliHLTSimulation::CreateInstance()
88 {
89   // see header file for function documentation
90   return new AliHLTSimulation;
91 }
92
93 int AliHLTSimulation::DeleteInstance(AliHLTSimulation* pSim)
94 {
95   // see header file for function documentation
96   assert(pSim!=NULL);
97   delete pSim;
98   return 0;
99 }
100
101 int AliHLTSimulation::Init(AliRunLoader* pRunLoader, const char* options)
102 {
103   // init the simulation
104   fOptions=options;
105   TString sysOp;
106
107   if(!fpPluginBase) {
108     AliError("internal initialization failed");
109     return -EINVAL;
110   }
111
112   AliHLTSystem* pSystem=fpPluginBase->GetInstance();
113   if (!pSystem) {
114     AliError("can not get AliHLTSystem instance");
115     return -ENOMEM;
116   }
117   if (pSystem->CheckStatus(AliHLTSystem::kError)) {
118     AliError("HLT system in error state");
119     return -EFAULT;
120   }
121
122   // scan options for specific entries
123   TObjArray* pTokens=fOptions.Tokenize(" ");
124   if (pTokens) {
125     int iEntries=pTokens->GetEntries();
126     for (int i=0; i<iEntries; i++) {
127       TString token=(((TObjString*)pTokens->At(i))->GetString());
128       if (token.Contains("rawfile=")) {
129         TString param=token.ReplaceAll("rawfile=", "");
130         if (param.EndsWith("/")) {
131           AliInfo(Form("creating AliRawReaderFile (%s)", param.Data()));
132           fpRawReader = new AliRawReaderFile(param);
133         } else if (param.EndsWith(".root")) {
134           AliInfo(Form("creating AliRawReaderRoot (%s)", param.Data()));
135           fpRawReader = new AliRawReaderRoot(param);
136         } else if (!param.IsNull()) {
137           AliInfo(Form("creating AliRawReaderDate (%s)", param.Data()));
138           fpRawReader = new AliRawReaderDate(param);
139         }
140         if (fpRawReader) {
141             fpRawReader->RewindEvents();
142             int count=0;
143             for ( ; fpRawReader->NextEvent(); count++) {/* empty body */};
144             if (count!=pRunLoader->GetNumberOfEvents()) {
145               AliError(Form("mismatch in event count: runloader %d, rawreader %d; ignoring rawreader", 
146                             pRunLoader->GetNumberOfEvents(), count));
147               count=0;
148             }
149             if (count>0) {
150               fpRawReader->RewindEvents();
151               fpRawReader->NextEvent();
152             } else {
153               delete fpRawReader;
154               fpRawReader=NULL;
155             }
156         }
157       } else if (token.Contains("writerawfiles=")) {
158         if (!token.ReplaceAll("writerawfiles=", "").Contains("HLT")) {
159           AliHLTOUTComponent::ClearGlobalOption(AliHLTOUTComponent::kWriteRawFiles);
160         }
161       } else {
162         if (sysOp.Length()>0) sysOp+=" ";
163         sysOp+=token;
164       }
165     }
166     delete pTokens;
167   }
168
169   AliCDBManager* man = AliCDBManager::Instance();
170   if (man && man->IsDefaultStorageSet())
171   {
172     // init solenoid field
173     // 2009-11-07 magnetic field handling fo HLT components has been switched to the
174     // global AliMagF instance, the HLT/ConfigHLT/SolenoidBz entry is obsolete
175     // The global instance is either established by the AliRoot environment or the
176     // component external interface.
177     if (TGeoGlobalMagField::Instance()->GetField()) {
178       AliDebug(0, Form("magnetic field: %f", AliTracker::GetBz()));
179     } else {
180       // workaround for bug #51285
181       AliGRPManager grpman;
182       if (grpman.ReadGRPEntry() &&
183           grpman.SetMagField()) {
184         // nothing to do any more
185       }
186       AliError(Form("can not get the AliMagF instance, falling back to GRP entry (%f)", AliTracker::GetBz()));
187     }
188   } else if (man) {
189     AliError("OCDB default storage not yet set, can not prepare OCDB entries");    
190   } else {
191     AliError("unable to get instance of AliCDBMetaData, can not prepare OCDB entries");    
192   }
193
194   // scan options
195   if (pSystem->ScanOptions(sysOp.Data())<0) {
196     AliError("error setting options for HLT system");
197     return -EINVAL;     
198   }
199
200   if (!pSystem->CheckStatus(AliHLTSystem::kReady)) {
201     if ((pSystem->Configure(fpRawReader, pRunLoader))<0) {
202       AliError("error during HLT system configuration");
203       return -EFAULT;
204     }
205   }
206
207   return 0;
208 }
209
210
211 int AliHLTSimulation::Run(AliRunLoader* pRunLoader)
212 {
213   // HLT reconstruction for simulated data  
214   if(!fpPluginBase) {
215     AliError("internal initialization failed");
216     return -EINVAL;
217   }
218
219   if(!pRunLoader) {
220     AliError("Missing RunLoader! 0x0");
221     return -EINVAL;
222   }
223
224   int nEvents = pRunLoader->GetNumberOfEvents();
225   int iResult=0;
226
227   AliHLTSystem* pSystem=fpPluginBase->GetInstance();
228   if (!pSystem) {
229     AliError("can not get AliHLTSystem instance");
230     return -ENOMEM;
231   }
232
233   if (pSystem->CheckStatus(AliHLTSystem::kError)) {
234     AliError("HLT system in error state");
235     return -EFAULT;
236   }
237
238   // Note: the rawreader is already placed at the first event
239   if ((iResult=pSystem->Reconstruct(1, pRunLoader, fpRawReader))>=0) {
240     pSystem->FillESD(0, pRunLoader, NULL);
241     for (int i=1; i<nEvents; i++) {
242       if (fpRawReader && !fpRawReader->NextEvent()) {
243         AliError("mismatch in event count, rawreader corrupted");
244         break;
245       }
246       pSystem->Reconstruct(1, pRunLoader, fpRawReader);
247       pSystem->FillESD(i, pRunLoader, NULL);
248     }
249     // send specific 'event' to execute the stop sequence
250     pSystem->Reconstruct(0, NULL, NULL);
251   }
252   return iResult;
253 }
254
255
256 AliHLTSimulation* AliHLTSimulationCreateInstance()
257 {
258   // see header file for function documentation
259   return AliHLTSimulation::CreateInstance();
260 }
261
262 int AliHLTSimulationDeleteInstance(AliHLTSimulation* pSim)
263 {
264   // see header file for function documentation
265   return AliHLTSimulation::DeleteInstance(pSim);
266 }
267
268 int AliHLTSimulationInit(AliHLTSimulation* pSim, AliRunLoader* pRunLoader, const char* options)
269 {
270   assert(pSim!=NULL);
271   if (pSim) {
272     return pSim->Init(pRunLoader, options);
273   }
274   return -ENODEV;
275 }
276
277 int AliHLTSimulationRun(AliHLTSimulation* pSim, AliRunLoader* pRunLoader)
278 {
279   assert(pSim!=NULL);
280   if (pSim) {
281     return pSim->Run(pRunLoader);
282   }
283   return -ENODEV;
284 }
285
286 int AliHLTSimulationGetLibraryVersion()
287 {
288   // see header file for function documentation
289   return LIBHLTSIM_VERSION;
290 }
291
292 int AliHLTSimulationSetup(AliHLTSimulation* /*pHLTSim*/, AliSimulation* pSim, const char* specificObjects)
293 {
294   // see header file for function documentation
295
296   // this is an attempt to solve issue #48360
297   // since there are many jobs running in parallel during the production,
298   // all the jobs want to put entries into the OCDB. The solution is to
299   // make them temporary, since they are only used to propagate information
300   // from the simulation to the reconstruction.
301
302   if (!pSim) return -EINVAL;
303   const char* entries[]={
304     NULL
305   };
306
307   TString specificStorage; 
308   specificStorage.Form("local://%s",gSystem->pwd());
309   for (const char** pEntry=entries; *pEntry!=NULL; pEntry++) {
310     const char* pObject=specificObjects?strstr(specificObjects, *pEntry):NULL;
311     if (pObject) {
312       // skip this entry if it is found in the list and either
313       // last one or separated by a blank
314       pObject+=strlen(*pEntry);
315       if (*pObject==0 || *pObject==' ') continue;
316     }
317     pSim->SetSpecificStorage(*pEntry, specificStorage.Data());
318   }
319
320   return 0;
321 }
322
323 #ifndef HAVE_COMPILEINFO
324 extern "C" void CompileInfo(const char*& date, const char*& time)
325 {
326   // the fall back compile info of the HLTsim library
327   // this is not up-to-date if other files have been changed and recompiled
328   date=__DATE__; time=__TIME__;
329   return;
330 }
331 #endif