removing the generation of the local solenoidBz OCDB entry
[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     int runNo=pRunLoader->GetHeader()->GetRun();
173
174     // init solenoid field
175     // 2009-11-07 magnetic field handling fo HLT components has been switched to the
176     // global AliMagF instance, the HLT/ConfigHLT/SolenoidBz entry is obsolete
177     // The global instance is either established by the AliRoot environment or the
178     // component external interface.
179     if (TGeoGlobalMagField::Instance()->GetField()) {
180       AliDebug(0, Form("magnetic field: %f", AliTracker::GetBz()));
181     } else {
182       // workaround for bug #51285
183       AliGRPManager grpman;
184       if (grpman.ReadGRPEntry() &&
185           grpman.SetMagField()) {
186         // nothing to do any more
187       }
188       AliError(Form("can not get the AliMagF instance, falling back to GRP entry (%f)", AliTracker::GetBz()));
189     }
190   } else if (man) {
191     AliError("OCDB default storage not yet set, can not prepare OCDB entries");    
192   } else {
193     AliError("unable to get instance of AliCDBMetaData, can not prepare OCDB entries");    
194   }
195
196   // scan options
197   if (pSystem->ScanOptions(sysOp.Data())<0) {
198     AliError("error setting options for HLT system");
199     return -EINVAL;     
200   }
201
202   if (!pSystem->CheckStatus(AliHLTSystem::kReady)) {
203     if ((pSystem->Configure(fpRawReader, pRunLoader))<0) {
204       AliError("error during HLT system configuration");
205       return -EFAULT;
206     }
207   }
208
209   return 0;
210 }
211
212
213 int AliHLTSimulation::Run(AliRunLoader* pRunLoader)
214 {
215   // HLT reconstruction for simulated data  
216   if(!fpPluginBase) {
217     AliError("internal initialization failed");
218     return -EINVAL;
219   }
220
221   if(!pRunLoader) {
222     AliError("Missing RunLoader! 0x0");
223     return -EINVAL;
224   }
225
226   int nEvents = pRunLoader->GetNumberOfEvents();
227   int iResult=0;
228
229   AliHLTSystem* pSystem=fpPluginBase->GetInstance();
230   if (!pSystem) {
231     AliError("can not get AliHLTSystem instance");
232     return -ENOMEM;
233   }
234
235   if (pSystem->CheckStatus(AliHLTSystem::kError)) {
236     AliError("HLT system in error state");
237     return -EFAULT;
238   }
239
240   // Note: the rawreader is already placed at the first event
241   if ((iResult=pSystem->Reconstruct(1, pRunLoader, fpRawReader))>=0) {
242     pSystem->FillESD(0, pRunLoader, NULL);
243     for (int i=1; i<nEvents; i++) {
244       if (fpRawReader && !fpRawReader->NextEvent()) {
245         AliError("mismatch in event count, rawreader corrupted");
246         break;
247       }
248       pSystem->Reconstruct(1, pRunLoader, fpRawReader);
249       pSystem->FillESD(i, pRunLoader, NULL);
250     }
251     // send specific 'event' to execute the stop sequence
252     pSystem->Reconstruct(0, NULL, NULL);
253   }
254   return iResult;
255 }
256
257
258 AliHLTSimulation* AliHLTSimulationCreateInstance()
259 {
260   // see header file for function documentation
261   return AliHLTSimulation::CreateInstance();
262 }
263
264 int AliHLTSimulationDeleteInstance(AliHLTSimulation* pSim)
265 {
266   // see header file for function documentation
267   return AliHLTSimulation::DeleteInstance(pSim);
268 }
269
270 int AliHLTSimulationInit(AliHLTSimulation* pSim, AliRunLoader* pRunLoader, const char* options)
271 {
272   assert(pSim!=NULL);
273   if (pSim) {
274     return pSim->Init(pRunLoader, options);
275   }
276   return -ENODEV;
277 }
278
279 int AliHLTSimulationRun(AliHLTSimulation* pSim, AliRunLoader* pRunLoader)
280 {
281   assert(pSim!=NULL);
282   if (pSim) {
283     return pSim->Run(pRunLoader);
284   }
285   return -ENODEV;
286 }
287
288 int AliHLTSimulationGetLibraryVersion()
289 {
290   // see header file for function documentation
291   return LIBHLTSIM_VERSION;
292 }
293
294 int AliHLTSimulationSetup(AliHLTSimulation* /*pHLTSim*/, AliSimulation* pSim, const char* specificObjects)
295 {
296   // see header file for function documentation
297
298   // this is an attempt to solve issue #48360
299   // since there are many jobs running in parallel during the production,
300   // all the jobs want to put entries into the OCDB. The solution is to
301   // make them temporary, since they are only used to propagate information
302   // from the simulation to the reconstruction.
303
304   if (!pSim) return -EINVAL;
305   const char* entries[]={
306     NULL
307   };
308
309   TString specificStorage; 
310   specificStorage.Form("local://%s",gSystem->pwd());
311   for (const char** pEntry=entries; *pEntry!=NULL; pEntry++) {
312     const char* pObject=specificObjects?strstr(specificObjects, *pEntry):NULL;
313     if (pObject) {
314       // skip this entry if it is found in the list and either
315       // last one or separated by a blank
316       pObject+=strlen(*pEntry);
317       if (*pObject==0 || *pObject==' ') continue;
318     }
319     pSim->SetSpecificStorage(*pEntry, specificStorage.Data());
320   }
321
322   return 0;
323 }
324
325 #ifndef HAVE_COMPILEINFO
326 extern "C" void CompileInfo(const char*& date, const char*& time)
327 {
328   // the fall back compile info of the HLTsim library
329   // this is not up-to-date if other files have been changed and recompiled
330   date=__DATE__; time=__TIME__;
331   return;
332 }
333 #endif