653d93c400e35841288a310a3d0809c1144bde4f
[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 "AliRun.h"
31 #include "AliRunLoader.h"
32 #include "AliHeader.h"
33 #include "AliTracker.h"
34 #include "AliCDBManager.h"
35 #include "AliCDBEntry.h"
36 #include "AliCDBPath.h"
37 #include "AliCDBId.h"
38 #include "AliCDBMetaData.h"
39 #include "AliHLTSystem.h"
40 #include "AliRawReaderFile.h"
41 #include "AliRawReaderDate.h"
42 #include "AliRawReaderRoot.h"
43 #include "AliESDEvent.h"
44 #include "AliHLTOUTComponent.h"
45
46 #if ALIHLTSIMULATION_LIBRARY_VERSION != LIBHLTSIM_VERSION
47 #error library version in header file and lib*.pkg do not match
48 #endif
49
50 /** ROOT macro for the implementation of ROOT specific class methods */
51 ClassImp(AliHLTSimulation);
52
53 AliHLTSimulation::AliHLTSimulation()
54   :
55   fOptions(),
56   fpSystem(NULL),
57   fpRawReader(NULL)
58 {
59   // see header file for class documentation
60   // or
61   // refer to README to build package
62   // or
63   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
64 }
65
66 AliHLTSimulation::~AliHLTSimulation()
67 {
68   // see header file for function documentation
69   if (fpSystem) {
70     delete fpSystem;
71   }
72   fpSystem=NULL;
73   if (fpRawReader) {
74     delete fpRawReader;
75   }
76   fpRawReader=NULL;
77 }
78
79 AliHLTSimulation* AliHLTSimulation::CreateInstance()
80 {
81   // see header file for function documentation
82   return new AliHLTSimulation;
83 }
84
85 int AliHLTSimulation::DeleteInstance(AliHLTSimulation* pSim)
86 {
87   // see header file for function documentation
88   assert(pSim!=NULL);
89   delete pSim;
90   return 0;
91 }
92
93 int AliHLTSimulation::Init(AliRunLoader* pRunLoader, const char* options)
94 {
95   // init the simulation
96   fOptions=options;
97   TString sysOp;
98
99   if (!fpSystem) fpSystem=new AliHLTSystem;
100   if (!fpSystem) {
101     AliError("can not create AliHLTSystem object");
102     return -ENOMEM;
103   }
104   if (fpSystem->CheckStatus(AliHLTSystem::kError)) {
105     AliError("HLT system in error state");
106     return -EFAULT;
107   }
108
109   // scan options for specific entries
110   TObjArray* pTokens=fOptions.Tokenize(" ");
111   if (pTokens) {
112     int iEntries=pTokens->GetEntries();
113     for (int i=0; i<iEntries; i++) {
114       TString token=(((TObjString*)pTokens->At(i))->GetString());
115       if (token.Contains("rawfile=")) {
116         TString param=token.ReplaceAll("rawfile=", "");
117         if (param.EndsWith("/")) {
118           AliInfo(Form("creating AliRawReaderFile (%s)", param.Data()));
119           fpRawReader = new AliRawReaderFile(param);
120         } else if (param.EndsWith(".root")) {
121           AliInfo(Form("creating AliRawReaderRoot (%s)", param.Data()));
122           fpRawReader = new AliRawReaderRoot(param);
123         } else if (!param.IsNull()) {
124           AliInfo(Form("creating AliRawReaderDate (%s)", param.Data()));
125           fpRawReader = new AliRawReaderDate(param);
126         }
127         if (fpRawReader) {
128             fpRawReader->RewindEvents();
129             int count=0;
130             for ( ; fpRawReader->NextEvent(); count++) {/* empty body */};
131             if (count!=pRunLoader->GetNumberOfEvents()) {
132               AliError(Form("mismatch in event count: runloader %d, rawreader %d; ignoring rawreader", 
133                             pRunLoader->GetNumberOfEvents(), count));
134               count=0;
135             }
136             if (count>0) {
137               fpRawReader->RewindEvents();
138               fpRawReader->NextEvent();
139             } else {
140               delete fpRawReader;
141               fpRawReader=NULL;
142             }
143         }
144       } else if (token.Contains("writerawfiles=")) {
145         if (!token.ReplaceAll("writerawfiles=", "").Contains("HLT")) {
146           AliHLTOUTComponent::ClearGlobalOption(AliHLTOUTComponent::kWriteRawFiles);
147         }
148       } else {
149         if (sysOp.Length()>0) sysOp+=" ";
150         sysOp+=token;
151       }
152     }
153     delete pTokens;
154   }
155
156   // init solenoid field
157   Double_t solenoidBz=AliTracker::GetBz();
158   AliCDBManager* man = AliCDBManager::Instance();
159   if (man && man->IsDefaultStorageSet())
160   {
161     const char* cdbSolenoidPath="HLT/ConfigHLT/SolenoidBz";
162     int runNo=pRunLoader->GetHeader()->GetRun();
163     TString cdbSolenoidParam;
164     cdbSolenoidParam.Form("-solenoidBz %f", solenoidBz);
165
166     // check if the entry is already there
167     AliCDBEntry *pEntry = man->Get(cdbSolenoidPath, runNo);
168     TObjString* pString=NULL;
169     if (pEntry) pString=dynamic_cast<TObjString*>(pEntry->GetObject());
170
171     if (!pEntry || !pString || pString->GetString().CompareTo(cdbSolenoidParam)!=0) {
172       TObjString obj(cdbSolenoidParam);
173       AliCDBPath cdbSolenoidEntry(cdbSolenoidPath);
174       AliCDBId cdbSolenoidId(cdbSolenoidEntry, runNo, runNo);
175       AliCDBMetaData cdbMetaData;
176       man->Put(&obj, cdbSolenoidId, &cdbMetaData);
177     }
178   }
179
180   // scan options
181   if (fpSystem->ScanOptions(sysOp.Data())<0) {
182     AliError("error setting options for HLT system");
183     return -EINVAL;     
184   }
185
186   if (!fpSystem->CheckStatus(AliHLTSystem::kReady)) {
187     if ((fpSystem->Configure(fpRawReader, pRunLoader))<0) {
188       AliError("error during HLT system configuration");
189       return -EFAULT;
190     }
191   }
192
193   return 0;
194 }
195
196
197 int AliHLTSimulation::Run(AliRunLoader* pRunLoader)
198 {
199   // HLT reconstruction for simulated data  
200   if(!pRunLoader) {
201     AliError("Missing RunLoader! 0x0");
202     return -EINVAL;
203   }
204
205   int nEvents = pRunLoader->GetNumberOfEvents();
206   int iResult=0;
207
208   if (fpSystem->CheckStatus(AliHLTSystem::kError)) {
209     AliError("HLT system in error state");
210     return -EFAULT;
211   }
212
213   // Note: the rawreader is already placed at the first event
214   if ((iResult=fpSystem->Reconstruct(1, pRunLoader, fpRawReader))>=0) {
215     fpSystem->FillESD(0, pRunLoader, NULL);
216     for (int i=1; i<nEvents; i++) {
217       if (fpRawReader && !fpRawReader->NextEvent()) {
218         AliError("mismatch in event count, rawreader corrupted");
219         break;
220       }
221       fpSystem->Reconstruct(1, pRunLoader, fpRawReader);
222       fpSystem->FillESD(i, pRunLoader, NULL);
223     }
224     // send specific 'event' to execute the stop sequence
225     fpSystem->Reconstruct(0, NULL, NULL);
226   }
227   return iResult;
228 }
229
230
231 AliHLTSimulation* AliHLTSimulationCreateInstance()
232 {
233   // see header file for function documentation
234   return AliHLTSimulation::CreateInstance();
235 }
236
237 int AliHLTSimulationDeleteInstance(AliHLTSimulation* pSim)
238 {
239   // see header file for function documentation
240   return AliHLTSimulation::DeleteInstance(pSim);
241 }
242
243 int AliHLTSimulationInit(AliHLTSimulation* pSim, AliRunLoader* pRunLoader, const char* options)
244 {
245   assert(pSim!=NULL);
246   if (pSim) {
247     return pSim->Init(pRunLoader, options);
248   }
249   return -ENODEV;
250 }
251
252 int AliHLTSimulationRun(AliHLTSimulation* pSim, AliRunLoader* pRunLoader)
253 {
254   assert(pSim!=NULL);
255   if (pSim) {
256     return pSim->Run(pRunLoader);
257   }
258   return -ENODEV;
259 }
260
261 int AliHLTSimulationGetLibraryVersion()
262 {
263   // see header file for function documentation
264   return LIBHLTSIM_VERSION;
265 }
266
267 extern "C" void AliHLTSimulationCompileInfo(const char*& date, const char*& time)
268 {
269   // the fall back compile info of the HLTsim library
270   // this is not up-to-date if other files have been changed and recompiled
271   date=__DATE__; time=__TIME__;
272   return;
273 }