changed format
[u/mrichter/AliRoot.git] / STEER / AliSimulation.cxx
CommitLineData
85a5290f 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
16/* $Id$ */
17
18///////////////////////////////////////////////////////////////////////////////
19// //
20// class for running generation, simulation and digitization //
21// //
22// Hits, sdigits and digits are created for all detectors by typing: //
23// //
24// AliSimulation sim; //
25// sim.Run(); //
26// //
27// The Run method returns kTRUE in case of successful execution. //
28// The number of events can be given as argument to the Run method or it //
29// can be set by //
30// //
31// sim.SetNumberOfEvents(n); //
32// //
95601147 33// The name of the configuration file can be passed as argument to the //
34// AliSimulation constructor or can be specified by //
85a5290f 35// //
36// sim.SetConfigFile("..."); //
37// //
38// The generation of particles and the simulation of detector hits can be //
39// switched on or off by //
40// //
41// sim.SetRunGeneration(kTRUE); // generation of primary particles //
42// sim.SetRunSimulation(kFALSE); // but no tracking //
43// //
44// For which detectors sdigits and digits will be created, can be steered //
45// by //
46// //
47// sim.SetMakeSDigits("ALL"); // make sdigits for all detectors //
48// sim.SetMakeDigits("ITS TPC"); // make digits only for ITS and TPC //
49// //
50// The argument is a (case sensitive) string with the names of the //
51// detectors separated by a space. An empty string ("") can be used to //
52// disable the creation of sdigits or digits. The special string "ALL" //
53// selects all available detectors. This is the default. //
54// //
55// The creation of digits from hits instead of from sdigits can be selected //
56// by //
57// //
58// sim.SetMakeDigitsFromHits("TRD"); //
59// //
60// The argument is again a string with the selected detectors. Be aware that //
61// this feature is not available for all detectors and that merging is not //
62// possible, when digits are created directly from hits. //
63// //
05526d44 64// Background events can be merged by calling //
85a5290f 65// //
66// sim.MergeWith("background/galice.root", 2); //
67// //
68// The first argument is the file name of the background galice file. The //
69// second argument is the number of signal events per background event. //
05526d44 70// By default this number is calculated from the number of available //
71// background events. MergeWith can be called several times to merge more //
72// than two event streams. It is assumed that the sdigits were already //
73// produced for the background events. //
85a5290f 74// //
0421c3d1 75// The output of raw data can be switched on by calling //
76// //
77// sim.SetWriteRawData("MUON"); // write raw data for MUON //
78// //
06c7e392 79// The default output format of the raw data are DDL files. They are //
80// converted to a DATE file, if a file name is given as second argument. //
81// For this conversion the program "dateStream" is required. If the file //
82// name has the extension ".root", the DATE file is converted to a root //
83// file. The program "alimdc" is used for this purpose. For the conversion //
84// to DATE and root format the two conversion programs have to be installed. //
85// Only the raw data in the final format is kept if the third argument is //
86// kTRUE. //
87// //
0421c3d1 88// The methods RunSimulation, RunSDigitization, RunDigitization, //
89// RunHitsDigitization and WriteRawData can be used to run only parts of //
06c7e392 90// the full simulation chain. The creation of raw data DDL files and their //
91// conversion to the DATE or root format can be run directly by calling //
92// the methods WriteRawFiles, ConvertRawFilesToDate and ConvertDateToRoot. //
95601147 93// //
18b43626 94// The default number of events per file, which is usually set in the //
95// config file, can be changed for individual detectors and data types //
96// by calling //
97// //
98// sim.SetEventsPerFile("PHOS", "Reconstructed Points", 3); //
99// //
100// The first argument is the detector, the second one the data type and the //
101// last one the number of events per file. Valid data types are "Hits", //
102// "Summable Digits", "Digits", "Reconstructed Points" and "Tracks". //
103// The number of events per file has to be set before the simulation of //
104// hits. Otherwise it has no effect. //
105// //
85a5290f 106///////////////////////////////////////////////////////////////////////////////
107
b856a511 108#include <TVirtualMCApplication.h>
e8d02863 109#include <TGeoManager.h>
85a5290f 110#include <TObjString.h>
af7ba10c 111#include <TSystem.h>
bfbd5665 112#include <TFile.h>
85a5290f 113
87932dab 114#include "AliCodeTimer.h"
e8d02863 115#include "AliCDBStorage.h"
116#include "AliCDBEntry.h"
117#include "AliCDBManager.h"
25be1e5c 118#include "AliGeomManager.h"
e8d02863 119#include "AliAlignObj.h"
120#include "AliCentralTrigger.h"
362c9d61 121#include "AliDAQ.h"
af7ba10c 122#include "AliDigitizer.h"
123#include "AliGenerator.h"
e8d02863 124#include "AliLog.h"
af7ba10c 125#include "AliModule.h"
126#include "AliRun.h"
127#include "AliRunDigitizer.h"
128#include "AliRunLoader.h"
129#include "AliSimulation.h"
130#include "AliVertexGenFile.h"
a5a091ce 131#include "AliCentralTrigger.h"
007155cc 132#include "AliCTPRawData.h"
ca30848f 133#include "AliRawReaderFile.h"
8b31e840 134#include "AliRawReaderRoot.h"
135#include "AliRawReaderDate.h"
ca30848f 136#include "AliESD.h"
137#include "AliHeader.h"
138#include "AliGenEventHeader.h"
b856a511 139#include "AliMC.h"
cae21299 140#include "AliHLTSimulation.h"
c65c502a 141#include "AliQADataMakerSteer.h"
27fc67fa 142#include "AliSysInfo.h"
85a5290f 143
144ClassImp(AliSimulation)
145
b856a511 146AliSimulation *AliSimulation::fgInstance = 0;
5b188f2f 147const char* AliSimulation::fgkDetectorName[AliSimulation::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT"};
85a5290f 148
149//_____________________________________________________________________________
795e4a22 150AliSimulation::AliSimulation(const char* configFileName,
95601147 151 const char* name, const char* title) :
152 TNamed(name, title),
153
154 fRunGeneration(kTRUE),
155 fRunSimulation(kTRUE),
024cf675 156 fLoadAlignFromCDB(kTRUE),
25be1e5c 157 fLoadAlObjsListOfDets("ALL"),
95601147 158 fMakeSDigits("ALL"),
159 fMakeDigits("ALL"),
a5a091ce 160 fMakeTrigger(""),
95601147 161 fMakeDigitsFromHits(""),
0421c3d1 162 fWriteRawData(""),
06c7e392 163 fRawDataFileName(""),
164 fDeleteIntermediateFiles(kFALSE),
67327b72 165 fWriteSelRawData(kFALSE),
95601147 166 fStopOnError(kFALSE),
167
168 fNEvents(1),
169 fConfigFileName(configFileName),
170 fGAliceFileName("galice.root"),
18b43626 171 fEventsPerFile(),
95601147 172 fBkgrdFileNames(NULL),
995ad051 173 fAlignObjArray(NULL),
04bae0a0 174 fUseBkgrdVertex(kTRUE),
024cf675 175 fRegionOfInterest(kFALSE),
795e4a22 176 fCDBUri(""),
ca30848f 177 fSpecCDBUri(),
795e4a22 178 fRun(-1),
179 fSeed(0),
180 fInitCDBCalled(kFALSE),
181 fInitRunNumberCalled(kFALSE),
182 fSetRunNumberFromDataCalled(kFALSE),
cae21299 183 fEmbeddingFlag(kFALSE),
759c1df1 184 fRunQA(kTRUE),
cae21299 185 fRunHLT("default")
85a5290f 186{
187// create simulation object with default parameters
b856a511 188 fgInstance = this;
0421c3d1 189 SetGAliceFile("galice.root");
5b188f2f 190
191// for QA
192 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++)
193 fQACycles[iDet] = 999999;
85a5290f 194}
195
196//_____________________________________________________________________________
197AliSimulation::AliSimulation(const AliSimulation& sim) :
95601147 198 TNamed(sim),
199
200 fRunGeneration(sim.fRunGeneration),
201 fRunSimulation(sim.fRunSimulation),
024cf675 202 fLoadAlignFromCDB(sim.fLoadAlignFromCDB),
25be1e5c 203 fLoadAlObjsListOfDets(sim.fLoadAlObjsListOfDets),
95601147 204 fMakeSDigits(sim.fMakeSDigits),
205 fMakeDigits(sim.fMakeDigits),
a5a091ce 206 fMakeTrigger(sim.fMakeTrigger),
95601147 207 fMakeDigitsFromHits(sim.fMakeDigitsFromHits),
0421c3d1 208 fWriteRawData(sim.fWriteRawData),
06c7e392 209 fRawDataFileName(""),
210 fDeleteIntermediateFiles(kFALSE),
67327b72 211 fWriteSelRawData(kFALSE),
95601147 212 fStopOnError(sim.fStopOnError),
213
214 fNEvents(sim.fNEvents),
215 fConfigFileName(sim.fConfigFileName),
216 fGAliceFileName(sim.fGAliceFileName),
18b43626 217 fEventsPerFile(),
95601147 218 fBkgrdFileNames(NULL),
995ad051 219 fAlignObjArray(NULL),
04bae0a0 220 fUseBkgrdVertex(sim.fUseBkgrdVertex),
024cf675 221 fRegionOfInterest(sim.fRegionOfInterest),
ec92bee0 222 fCDBUri(sim.fCDBUri),
ca30848f 223 fSpecCDBUri(),
795e4a22 224 fRun(-1),
225 fSeed(0),
226 fInitCDBCalled(sim.fInitCDBCalled),
227 fInitRunNumberCalled(sim.fInitRunNumberCalled),
228 fSetRunNumberFromDataCalled(sim.fSetRunNumberFromDataCalled),
c65c502a 229 fEmbeddingFlag(sim.fEmbeddingFlag),
759c1df1 230 fRunQA(kTRUE),
c65c502a 231 fRunHLT(sim.fRunHLT)
85a5290f 232{
233// copy constructor
234
18b43626 235 for (Int_t i = 0; i < sim.fEventsPerFile.GetEntriesFast(); i++) {
236 if (!sim.fEventsPerFile[i]) continue;
237 fEventsPerFile.Add(sim.fEventsPerFile[i]->Clone());
238 }
239
85a5290f 240 fBkgrdFileNames = new TObjArray;
241 for (Int_t i = 0; i < sim.fBkgrdFileNames->GetEntriesFast(); i++) {
242 if (!sim.fBkgrdFileNames->At(i)) continue;
243 fBkgrdFileNames->Add(sim.fBkgrdFileNames->At(i)->Clone());
244 }
ec92bee0 245
246 for (Int_t i = 0; i < sim.fSpecCDBUri.GetEntriesFast(); i++) {
247 if (sim.fSpecCDBUri[i]) fSpecCDBUri.Add(sim.fSpecCDBUri[i]->Clone());
248 }
b856a511 249 fgInstance = this;
5b188f2f 250
251// for QA
252 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++)
253 fQACycles[iDet] = sim.fQACycles[iDet];
85a5290f 254}
255
256//_____________________________________________________________________________
257AliSimulation& AliSimulation::operator = (const AliSimulation& sim)
258{
259// assignment operator
260
261 this->~AliSimulation();
262 new(this) AliSimulation(sim);
263 return *this;
264}
265
266//_____________________________________________________________________________
267AliSimulation::~AliSimulation()
268{
269// clean up
270
18b43626 271 fEventsPerFile.Delete();
024cf675 272// if(fAlignObjArray) fAlignObjArray->Delete(); // fAlignObjArray->RemoveAll() ???
273// delete fAlignObjArray; fAlignObjArray=0;
18b43626 274
95601147 275 if (fBkgrdFileNames) {
276 fBkgrdFileNames->Delete();
277 delete fBkgrdFileNames;
278 }
ec92bee0 279
280 fSpecCDBUri.Delete();
b856a511 281 if (fgInstance==this) fgInstance = 0;
87932dab 282
283 AliCodeTimer::Instance()->Print();
85a5290f 284}
285
286
287//_____________________________________________________________________________
288void AliSimulation::SetNumberOfEvents(Int_t nEvents)
289{
290// set the number of events for one run
291
292 fNEvents = nEvents;
293}
294
295//_____________________________________________________________________________
795e4a22 296void AliSimulation::InitCDB()
024cf675 297{
298// activate a default CDB storage
299// First check if we have any CDB storage set, because it is used
300// to retrieve the calibration and alignment constants
301
795e4a22 302 if (fInitCDBCalled) return;
303 fInitCDBCalled = kTRUE;
304
024cf675 305 AliCDBManager* man = AliCDBManager::Instance();
ec92bee0 306 if (man->IsDefaultStorageSet())
024cf675 307 {
ec92bee0 308 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
309 AliWarning("Default CDB storage has been already set !");
ced249e6 310 AliWarning(Form("Ignoring the default storage declared in AliSimulation: %s",fCDBUri.Data()));
ec92bee0 311 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
795e4a22 312 fCDBUri = man->GetDefaultStorage()->GetURI();
ec92bee0 313 }
314 else {
795e4a22 315 if (fCDBUri.Length() > 0)
316 {
317 AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
318 AliDebug(2, Form("Default CDB storage is set to: %s", fCDBUri.Data()));
319 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
320 } else {
321 fCDBUri="local://$ALICE_ROOT";
322 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
323 AliWarning("Default CDB storage not yet set !!!!");
324 AliWarning(Form("Setting it now to: %s", fCDBUri.Data()));
325 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
326
327 }
ec92bee0 328 man->SetDefaultStorage(fCDBUri);
329 }
330
331 // Now activate the detector specific CDB storage locations
332 for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
333 TObject* obj = fSpecCDBUri[i];
334 if (!obj) continue;
b8ec52f6 335 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
336 AliDebug(2, Form("Specific CDB storage for %s is set to: %s",obj->GetName(),obj->GetTitle()));
337 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
c3a7b59a 338 man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
ec92bee0 339 }
795e4a22 340
024cf675 341}
342
343//_____________________________________________________________________________
795e4a22 344void AliSimulation::InitRunNumber(){
345// check run number. If not set, set it to 0 !!!!
346
347 if (fInitRunNumberCalled) return;
348 fInitRunNumberCalled = kTRUE;
349
350 AliCDBManager* man = AliCDBManager::Instance();
351 if (man->GetRun() >= 0)
352 {
8c8fbdcd 353 AliFatal(Form("Run number cannot be set in AliCDBManager before start of simulation: "
354 "Use external variable DC_RUN or AliSimulation::SetRun()!"));
795e4a22 355 }
8c8fbdcd 356
357 if(fRun >= 0) {
795e4a22 358 AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
359 AliDebug(2, Form("Setting CDB run number to: %d",fRun));
360 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
8c8fbdcd 361 } else {
795e4a22 362 fRun=0;
363 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
364 AliWarning("Run number not yet set !!!!");
365 AliWarning(Form("Setting it now to: %d", fRun));
366 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
367
795e4a22 368 }
8c8fbdcd 369 man->SetRun(fRun);
024cf675 370
795e4a22 371 man->Print();
024cf675 372
373}
374
375//_____________________________________________________________________________
795e4a22 376void AliSimulation::SetCDBLock() {
377 // Set CDB lock: from now on it is forbidden to reset the run number
378 // or the default storage or to activate any further storage!
379
380 AliCDBManager::Instance()->SetLock(1);
381}
382
383//_____________________________________________________________________________
384void AliSimulation::SetDefaultStorage(const char* uri) {
385// Store the desired default CDB storage location
00aa02d5 386// Activate it later within the Run() method
00aa02d5 387
795e4a22 388 fCDBUri = uri;
00aa02d5 389
390}
391
392//_____________________________________________________________________________
c3a7b59a 393void AliSimulation::SetSpecificStorage(const char* calibType, const char* uri) {
ec92bee0 394// Store a detector-specific CDB storage location
395// Activate it later within the Run() method
024cf675 396
c3a7b59a 397 AliCDBPath aPath(calibType);
398 if(!aPath.IsValid()){
399 AliError(Form("Not a valid path: %s", calibType));
400 return;
401 }
402
403 TObject* obj = fSpecCDBUri.FindObject(calibType);
ec92bee0 404 if (obj) fSpecCDBUri.Remove(obj);
c3a7b59a 405 fSpecCDBUri.Add(new TNamed(calibType, uri));
024cf675 406
407}
408
409//_____________________________________________________________________________
795e4a22 410void AliSimulation::SetRunNumber(Int_t run)
411{
412// sets run number
413// Activate it later within the Run() method
414
415 fRun = run;
416}
417
418//_____________________________________________________________________________
419void AliSimulation::SetSeed(Int_t seed)
420{
421// sets seed number
422// Activate it later within the Run() method
423
424 fSeed = seed;
425}
426
427//_____________________________________________________________________________
428Bool_t AliSimulation::SetRunNumberFromData()
429{
430 // Set the CDB manager run number
431 // The run number is retrieved from gAlice
432
433 if (fSetRunNumberFromDataCalled) return kTRUE;
434 fSetRunNumberFromDataCalled = kTRUE;
435
436 AliCDBManager* man = AliCDBManager::Instance();
437 Int_t runData = -1, runCDB = -1;
438
439 AliRunLoader* runLoader = LoadRun("READ");
440 if (!runLoader) return kFALSE;
441 else {
442 runData = runLoader->GetAliRun()->GetHeader()->GetRun();
443 delete runLoader;
444 }
445
446 runCDB = man->GetRun();
447 if(runCDB >= 0) {
448 if (runCDB != runData) {
449 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
450 AliWarning(Form("A run number was previously set in AliCDBManager: %d !", runCDB));
451 AliWarning(Form("It will be replaced with the run number got from run header: %d !", runData));
452 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
453 }
454
455 }
456
457 man->SetRun(runData);
458 fRun = runData;
459
460 if(man->GetRun() < 0) {
461 AliError("Run number not properly initalized!");
462 return kFALSE;
463 }
464
465 man->Print();
466
467 return kTRUE;
468}
469
470//_____________________________________________________________________________
85a5290f 471void AliSimulation::SetConfigFile(const char* fileName)
472{
473// set the name of the config file
474
475 fConfigFileName = fileName;
476}
477
478//_____________________________________________________________________________
0421c3d1 479void AliSimulation::SetGAliceFile(const char* fileName)
480{
481// set the name of the galice file
482// the path is converted to an absolute one if it is relative
483
484 fGAliceFileName = fileName;
485 if (!gSystem->IsAbsoluteFileName(fGAliceFileName)) {
486 char* absFileName = gSystem->ConcatFileName(gSystem->WorkingDirectory(),
487 fGAliceFileName);
488 fGAliceFileName = absFileName;
489 delete[] absFileName;
490 }
ac1671c0 491
492 AliDebug(2, Form("galice file name set to %s", fileName));
0421c3d1 493}
494
495//_____________________________________________________________________________
18b43626 496void AliSimulation::SetEventsPerFile(const char* detector, const char* type,
497 Int_t nEvents)
498{
499// set the number of events per file for the given detector and data type
500// ("Hits", "Summable Digits", "Digits", "Reconstructed Points" or "Tracks")
501
502 TNamed* obj = new TNamed(detector, type);
503 obj->SetUniqueID(nEvents);
504 fEventsPerFile.Add(obj);
505}
506
507//_____________________________________________________________________________
6bae477a 508Bool_t AliSimulation::MisalignGeometry(AliRunLoader *runLoader)
509{
510 // Read the alignment objects from CDB.
511 // Each detector is supposed to have the
512 // alignment objects in DET/Align/Data CDB path.
513 // All the detector objects are then collected,
514 // sorted by geometry level (starting from ALIC) and
515 // then applied to the TGeo geometry.
516 // Finally an overlaps check is performed.
517
74ae4297 518 if (!AliGeomManager::GetGeometry() || !AliGeomManager::GetGeometry()->IsClosed()) {
519 AliError("Can't apply the misalignment! Geometry is not loaded or it is still opened!");
0717eed2 520 return kFALSE;
521 }
795e4a22 522
523 // initialize CDB storage, run number, set CDB lock
524 InitCDB();
525// if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
526 SetCDBLock();
527
6bae477a 528 Bool_t delRunLoader = kFALSE;
529 if (!runLoader) {
530 runLoader = LoadRun("READ");
531 if (!runLoader) return kFALSE;
532 delRunLoader = kTRUE;
533 }
795e4a22 534
b856a511 535 // Export ideal geometry
ced249e6 536 if(!gAlice->IsRootGeometry()) AliGeomManager::GetGeometry()->Export("geometry.root");
b856a511 537
25be1e5c 538 // Load alignment data from CDB and apply to geometry through AliGeomManager
6bae477a 539 if(fLoadAlignFromCDB){
25be1e5c 540
541 TString detStr = fLoadAlObjsListOfDets;
542 TString loadAlObjsListOfDets = "";
543
544 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
545 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
546 AliModule* det = (AliModule*) detArray->At(iDet);
547 if (!det || !det->IsActive()) continue;
548 if (IsSelected(det->GetName(), detStr)) {
0717eed2 549 //add det to list of dets to be aligned from CDB
550 loadAlObjsListOfDets += det->GetName();
551 loadAlObjsListOfDets += " ";
25be1e5c 552 }
553 } // end loop over detectors
53dd3c3d 554 loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
45daac75 555 AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
25be1e5c 556 }else{
557 // Check if the array with alignment objects was
558 // provided by the user. If yes, apply the objects
559 // to the present TGeo geometry
560 if (fAlignObjArray) {
45daac75 561 if (AliGeomManager::ApplyAlignObjsToGeom(*fAlignObjArray) == kFALSE) {
0717eed2 562 AliError("The misalignment of one or more volumes failed!"
563 "Compare the list of simulated detectors and the list of detector alignment data!");
564 if (delRunLoader) delete runLoader;
565 return kFALSE;
6bae477a 566 }
567 }
6bae477a 568 }
569
ef7ff1f9 570 // Update the internal geometry of modules (ITS needs it)
25be1e5c 571 TString detStr = fLoadAlObjsListOfDets;
ef7ff1f9 572 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
573 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
574
575 AliModule* det = (AliModule*) detArray->At(iDet);
576 if (!det || !det->IsActive()) continue;
577 if (IsSelected(det->GetName(), detStr)) {
578 det->UpdateInternalGeometry();
579 }
580 } // end loop over detectors
581
582
6bae477a 583 if (delRunLoader) delete runLoader;
584
585 return kTRUE;
586}
587
6bae477a 588//_____________________________________________________________________________
85a5290f 589void AliSimulation::MergeWith(const char* fileName, Int_t nSignalPerBkgrd)
590{
591// add a file with background events for merging
592
593 TObjString* fileNameStr = new TObjString(fileName);
594 fileNameStr->SetUniqueID(nSignalPerBkgrd);
95601147 595 if (!fBkgrdFileNames) fBkgrdFileNames = new TObjArray;
85a5290f 596 fBkgrdFileNames->Add(fileNameStr);
597}
598
ca30848f 599void AliSimulation::EmbedInto(const char* fileName, Int_t nSignalPerBkgrd)
600{
601// add a file with background events for embeddin
602 MergeWith(fileName, nSignalPerBkgrd);
603 fEmbeddingFlag = kTRUE;
604}
85a5290f 605
606//_____________________________________________________________________________
607Bool_t AliSimulation::Run(Int_t nEvents)
608{
609// run the generation, simulation and digitization
610
c65c502a 611
795e4a22 612 AliCodeTimerAuto("")
87932dab 613
795e4a22 614 // Load run number and seed from environmental vars
615 ProcessEnvironmentVars();
b0314964 616
795e4a22 617 gRandom->SetSeed(fSeed);
618
85a5290f 619 if (nEvents > 0) fNEvents = nEvents;
620
621 // generation and simulation -> hits
622 if (fRunGeneration) {
85a5290f 623 if (!RunSimulation()) if (fStopOnError) return kFALSE;
624 }
795e4a22 625
626 // initialize CDB storage from external environment
627 // (either CDB manager or AliSimulation setters),
628 // if not already done in RunSimulation()
629 InitCDB();
630
631 // Set run number in CDBManager from data
632 // From this point on the run number must be always loaded from data!
633 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
634
635 // Set CDB lock: from now on it is forbidden to reset the run number
636 // or the default storage or to activate any further storage!
637 SetCDBLock();
6bae477a 638
25be1e5c 639 // If RunSimulation was not called, load the geometry and misalign it
74ae4297 640 if (!AliGeomManager::GetGeometry()) {
641 // Initialize the geometry manager
45daac75 642 AliGeomManager::LoadGeometry("geometry.root");
74ae4297 643 if (!AliGeomManager::GetGeometry()) if (fStopOnError) return kFALSE;
644 // Misalign geometry
25be1e5c 645 if(!MisalignGeometry()) if (fStopOnError) return kFALSE;
6bae477a 646 }
25be1e5c 647
27fc67fa 648
85a5290f 649 // hits -> summable digits
27fc67fa 650 AliSysInfo::AddStamp("Start_sdigitization");
85a5290f 651 if (!fMakeSDigits.IsNull()) {
652 if (!RunSDigitization(fMakeSDigits)) if (fStopOnError) return kFALSE;
a1b90a73 653
85a5290f 654 }
27fc67fa 655 AliSysInfo::AddStamp("Stop_sdigitization");
c65c502a 656
27fc67fa 657 AliSysInfo::AddStamp("Start_digitization");
795e4a22 658 // summable digits -> digits
85a5290f 659 if (!fMakeDigits.IsNull()) {
660 if (!RunDigitization(fMakeDigits, fMakeDigitsFromHits)) {
661 if (fStopOnError) return kFALSE;
662 }
a1b90a73 663 }
27fc67fa 664 AliSysInfo::AddStamp("Stop_digitization");
85a5290f 665
795e4a22 666
667
85a5290f 668 // hits -> digits
669 if (!fMakeDigitsFromHits.IsNull()) {
95601147 670 if (fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
ac1671c0 671 AliWarning(Form("Merging and direct creation of digits from hits "
672 "was selected for some detectors. "
673 "No merging will be done for the following detectors: %s",
674 fMakeDigitsFromHits.Data()));
85a5290f 675 }
676 if (!RunHitsDigitization(fMakeDigitsFromHits)) {
677 if (fStopOnError) return kFALSE;
678 }
679 }
680
795e4a22 681
682
a5a091ce 683 // digits -> trigger
8480396b 684 if (!RunTrigger(fMakeTrigger,fMakeDigits)) {
087426de 685 if (fStopOnError) return kFALSE;
a5a091ce 686 }
687
795e4a22 688
689
0421c3d1 690 // digits -> raw data
691 if (!fWriteRawData.IsNull()) {
06c7e392 692 if (!WriteRawData(fWriteRawData, fRawDataFileName,
67327b72 693 fDeleteIntermediateFiles,fWriteSelRawData)) {
0421c3d1 694 if (fStopOnError) return kFALSE;
695 }
696 }
697
795e4a22 698
699
cae21299 700 // run HLT simulation
701 if (!fRunHLT.IsNull()) {
702 if (!RunHLT()) {
703 if (fStopOnError) return kFALSE;
704 }
705 }
795e4a22 706
04236e67 707 //QA
708 if (fRunQA) {
709 Bool_t rv = RunQA() ;
710 if (!rv)
711 if (fStopOnError)
712 return kFALSE ;
713 }
795e4a22 714
715 // Cleanup of CDB manager: cache and active storages!
716 AliCDBManager::Instance()->ClearCache();
717
85a5290f 718 return kTRUE;
719}
720
721//_____________________________________________________________________________
8480396b 722Bool_t AliSimulation::RunTrigger(const char* config, const char* detectors)
a5a091ce 723{
724 // run the trigger
725
87932dab 726 AliCodeTimerAuto("")
a5a091ce 727
795e4a22 728 // initialize CDB storage from external environment
729 // (either CDB manager or AliSimulation setters),
730 // if not already done in RunSimulation()
731 InitCDB();
732
733 // Set run number in CDBManager from data
734 // From this point on the run number must be always loaded from data!
735 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
736
737 // Set CDB lock: from now on it is forbidden to reset the run number
738 // or the default storage or to activate any further storage!
739 SetCDBLock();
740
bacbe0fd 741 AliRunLoader* runLoader = LoadRun("READ");
742 if (!runLoader) return kFALSE;
51f6d619 743 TString trconfiguration = config;
bacbe0fd 744
51f6d619 745 if (trconfiguration.IsNull()) {
087426de 746 if (gAlice->GetTriggerDescriptor() != "") {
51f6d619 747 trconfiguration = gAlice->GetTriggerDescriptor();
087426de 748 }
51f6d619 749 else
8480396b 750 AliWarning("No trigger descriptor is specified. Loading the one that is in the CDB.");
087426de 751 }
752
0f46f5fa 753 runLoader->MakeTree( "GG" );
bacbe0fd 754 AliCentralTrigger* aCTP = runLoader->GetTrigger();
51f6d619 755 // Load Configuration
756 if (!aCTP->LoadConfiguration( trconfiguration ))
757 return kFALSE;
a5a091ce 758
51f6d619 759 // digits -> trigger
8480396b 760 if( !aCTP->RunTrigger( runLoader , detectors ) ) {
a5a091ce 761 if (fStopOnError) {
51f6d619 762 // delete aCTP;
763 return kFALSE;
a5a091ce 764 }
bacbe0fd 765 }
a5a091ce 766
bacbe0fd 767 delete runLoader;
a5a091ce 768
bacbe0fd 769 return kTRUE;
a5a091ce 770}
771
007155cc 772//_____________________________________________________________________________
773Bool_t AliSimulation::WriteTriggerRawData()
774{
775 // Writes the CTP (trigger) DDL raw data
776 // Details of the format are given in the
777 // trigger TDR - pages 134 and 135.
778 AliCTPRawData writer;
779 writer.RawData();
a5a091ce 780
007155cc 781 return kTRUE;
782}
a5a091ce 783
784//_____________________________________________________________________________
95601147 785Bool_t AliSimulation::RunSimulation(Int_t nEvents)
85a5290f 786{
787// run the generation and simulation
788
87932dab 789 AliCodeTimerAuto("")
4df28b43 790
795e4a22 791 // initialize CDB storage and run number from external environment
792 // (either CDB manager or AliSimulation setters)
793 InitCDB();
794 InitRunNumber();
795 SetCDBLock();
796
95601147 797 if (!gAlice) {
ac1671c0 798 AliError("no gAlice object. Restart aliroot and try again.");
95601147 799 return kFALSE;
800 }
801 if (gAlice->Modules()->GetEntries() > 0) {
ac1671c0 802 AliError("gAlice was already run. Restart aliroot and try again.");
95601147 803 return kFALSE;
804 }
805
ac1671c0 806 AliInfo(Form("initializing gAlice with config file %s",
807 fConfigFileName.Data()));
815c2b38 808 StdoutToAliInfo(StderrToAliError(
809 gAlice->Init(fConfigFileName.Data());
810 ););
795e4a22 811
087426de 812 // Get the trigger descriptor string
813 // Either from AliSimulation or from
814 // gAlice
815 if (fMakeTrigger.IsNull()) {
816 if (gAlice->GetTriggerDescriptor() != "")
817 fMakeTrigger = gAlice->GetTriggerDescriptor();
818 }
819 else
820 gAlice->SetTriggerDescriptor(fMakeTrigger.Data());
821
6bae477a 822 // Set run number in CDBManager
024cf675 823 AliInfo(Form("Run number: %d",AliCDBManager::Instance()->GetRun()));
824
825 AliRunLoader* runLoader = gAlice->GetRunLoader();
826 if (!runLoader) {
827 AliError(Form("gAlice has no run loader object. "
828 "Check your config file: %s", fConfigFileName.Data()));
829 return kFALSE;
830 }
831 SetGAliceFile(runLoader->GetFileName());
795e4a22 832
6bae477a 833 // Misalign geometry
caf9c464 834#if ROOT_VERSION_CODE < 331527
74ae4297 835 AliGeomManager::SetGeometry(gGeoManager);
caf9c464 836 MisalignGeometry(runLoader);
837#endif
995ad051 838
024cf675 839// AliRunLoader* runLoader = gAlice->GetRunLoader();
840// if (!runLoader) {
841// AliError(Form("gAlice has no run loader object. "
842// "Check your config file: %s", fConfigFileName.Data()));
843// return kFALSE;
844// }
845// SetGAliceFile(runLoader->GetFileName());
85a5290f 846
04bae0a0 847 if (!gAlice->Generator()) {
ac1671c0 848 AliError(Form("gAlice has no generator object. "
849 "Check your config file: %s", fConfigFileName.Data()));
04bae0a0 850 return kFALSE;
851 }
05526d44 852 if (nEvents <= 0) nEvents = fNEvents;
04bae0a0 853
854 // get vertex from background file in case of merging
855 if (fUseBkgrdVertex &&
856 fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
05526d44 857 Int_t signalPerBkgrd = GetNSignalPerBkgrd(nEvents);
04bae0a0 858 const char* fileName = ((TObjString*)
859 (fBkgrdFileNames->At(0)))->GetName();
ac1671c0 860 AliInfo(Form("The vertex will be taken from the background "
861 "file %s with nSignalPerBackground = %d",
862 fileName, signalPerBkgrd));
04bae0a0 863 AliVertexGenFile* vtxGen = new AliVertexGenFile(fileName, signalPerBkgrd);
864 gAlice->Generator()->SetVertexGenerator(vtxGen);
865 }
866
85a5290f 867 if (!fRunSimulation) {
85a5290f 868 gAlice->Generator()->SetTrackingFlag(0);
869 }
870
18b43626 871 // set the number of events per file for given detectors and data types
872 for (Int_t i = 0; i < fEventsPerFile.GetEntriesFast(); i++) {
873 if (!fEventsPerFile[i]) continue;
874 const char* detName = fEventsPerFile[i]->GetName();
875 const char* typeName = fEventsPerFile[i]->GetTitle();
876 TString loaderName(detName);
877 loaderName += "Loader";
878 AliLoader* loader = runLoader->GetLoader(loaderName);
879 if (!loader) {
ac1671c0 880 AliError(Form("RunSimulation", "no loader for %s found\n"
881 "Number of events per file not set for %s %s",
882 detName, typeName, detName));
18b43626 883 continue;
884 }
885 AliDataLoader* dataLoader =
886 loader->GetDataLoader(typeName);
887 if (!dataLoader) {
ac1671c0 888 AliError(Form("no data loader for %s found\n"
889 "Number of events per file not set for %s %s",
890 typeName, detName, typeName));
18b43626 891 continue;
892 }
893 dataLoader->SetNumberOfEventsPerFile(fEventsPerFile[i]->GetUniqueID());
ac1671c0 894 AliDebug(1, Form("number of events per file set to %d for %s %s",
895 fEventsPerFile[i]->GetUniqueID(), detName, typeName));
18b43626 896 }
897
ac1671c0 898 AliInfo("running gAlice");
27fc67fa 899 AliSysInfo::AddStamp("Start_simulation");
815c2b38 900 StdoutToAliInfo(StderrToAliError(
901 gAlice->Run(nEvents);
902 ););
27fc67fa 903 AliSysInfo::AddStamp("Stop_simulation");
95601147 904 delete runLoader;
85a5290f 905
906 return kTRUE;
907}
908
909//_____________________________________________________________________________
95601147 910Bool_t AliSimulation::RunSDigitization(const char* detectors)
85a5290f 911{
912// run the digitization and produce summable digits
27fc67fa 913 static Int_t eventNr=0;
87932dab 914 AliCodeTimerAuto("")
4df28b43 915
795e4a22 916 // initialize CDB storage, run number, set CDB lock
917 InitCDB();
918 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
919 SetCDBLock();
920
95601147 921 AliRunLoader* runLoader = LoadRun();
922 if (!runLoader) return kFALSE;
923
85a5290f 924 TString detStr = detectors;
95601147 925 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
85a5290f 926 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
927 AliModule* det = (AliModule*) detArray->At(iDet);
928 if (!det || !det->IsActive()) continue;
929 if (IsSelected(det->GetName(), detStr)) {
ac1671c0 930 AliInfo(Form("creating summable digits for %s", det->GetName()));
87932dab 931 AliCodeTimerAuto(Form("creating summable digits for %s", det->GetName()));
85a5290f 932 det->Hits2SDigits();
27fc67fa 933 AliSysInfo::AddStamp(Form("Digit_%s_%d",det->GetName(),eventNr), 0,1, eventNr);
85a5290f 934 }
935 }
936
937 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
ac1671c0 938 AliError(Form("the following detectors were not found: %s",
939 detStr.Data()));
85a5290f 940 if (fStopOnError) return kFALSE;
941 }
27fc67fa 942 eventNr++;
95601147 943 delete runLoader;
944
85a5290f 945 return kTRUE;
946}
947
948
949//_____________________________________________________________________________
95601147 950Bool_t AliSimulation::RunDigitization(const char* detectors,
951 const char* excludeDetectors)
85a5290f 952{
953// run the digitization and produce digits from sdigits
954
87932dab 955 AliCodeTimerAuto("")
4df28b43 956
795e4a22 957 // initialize CDB storage, run number, set CDB lock
958 InitCDB();
959 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
960 SetCDBLock();
961
95601147 962 while (AliRunLoader::GetRunLoader()) delete AliRunLoader::GetRunLoader();
963 if (gAlice) delete gAlice;
964 gAlice = NULL;
965
966 Int_t nStreams = 1;
05526d44 967 if (fBkgrdFileNames) nStreams = fBkgrdFileNames->GetEntriesFast() + 1;
968 Int_t signalPerBkgrd = GetNSignalPerBkgrd();
85a5290f 969 AliRunDigitizer* manager = new AliRunDigitizer(nStreams, signalPerBkgrd);
ca30848f 970 // manager->SetEmbeddingFlag(fEmbeddingFlag);
85a5290f 971 manager->SetInputStream(0, fGAliceFileName.Data());
972 for (Int_t iStream = 1; iStream < nStreams; iStream++) {
973 const char* fileName = ((TObjString*)
974 (fBkgrdFileNames->At(iStream-1)))->GetName();
975 manager->SetInputStream(iStream, fileName);
976 }
977
978 TString detStr = detectors;
979 TString detExcl = excludeDetectors;
95601147 980 manager->GetInputStream(0)->ImportgAlice();
981 AliRunLoader* runLoader =
982 AliRunLoader::GetRunLoader(manager->GetInputStream(0)->GetFolderName());
983 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
85a5290f 984 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
985 AliModule* det = (AliModule*) detArray->At(iDet);
986 if (!det || !det->IsActive()) continue;
987 if (IsSelected(det->GetName(), detStr) &&
988 !IsSelected(det->GetName(), detExcl)) {
4df28b43 989 AliDigitizer* digitizer = det->CreateDigitizer(manager);
ca30848f 990
4df28b43 991 if (!digitizer) {
ac1671c0 992 AliError(Form("no digitizer for %s", det->GetName()));
85a5290f 993 if (fStopOnError) return kFALSE;
4df28b43 994 } else {
995 digitizer->SetRegionOfInterest(fRegionOfInterest);
85a5290f 996 }
997 }
998 }
999
1000 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
ac1671c0 1001 AliError(Form("the following detectors were not found: %s",
1002 detStr.Data()));
85a5290f 1003 if (fStopOnError) return kFALSE;
1004 }
1005
1006 if (!manager->GetListOfTasks()->IsEmpty()) {
ac1671c0 1007 AliInfo("executing digitization");
85a5290f 1008 manager->Exec("");
1009 }
95601147 1010
85a5290f 1011 delete manager;
1012
1013 return kTRUE;
1014}
1015
1016//_____________________________________________________________________________
95601147 1017Bool_t AliSimulation::RunHitsDigitization(const char* detectors)
85a5290f 1018{
1019// run the digitization and produce digits from hits
1020
87932dab 1021 AliCodeTimerAuto("")
4df28b43 1022
795e4a22 1023 // initialize CDB storage, run number, set CDB lock
1024 InitCDB();
1025 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
1026 SetCDBLock();
1027
591f51bb 1028 AliRunLoader* runLoader = LoadRun("READ");
95601147 1029 if (!runLoader) return kFALSE;
1030
85a5290f 1031 TString detStr = detectors;
95601147 1032 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
85a5290f 1033 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1034 AliModule* det = (AliModule*) detArray->At(iDet);
1035 if (!det || !det->IsActive()) continue;
1036 if (IsSelected(det->GetName(), detStr)) {
ac1671c0 1037 AliInfo(Form("creating digits from hits for %s", det->GetName()));
85a5290f 1038 det->Hits2Digits();
1039 }
1040 }
1041
1042 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
ac1671c0 1043 AliError(Form("the following detectors were not found: %s",
1044 detStr.Data()));
85a5290f 1045 if (fStopOnError) return kFALSE;
1046 }
1047
b17cac0f 1048 delete runLoader;
591f51bb 1049 //PH Temporary fix to avoid interference with the PHOS loder/getter
1050 //PH The problem has to be solved in more general way 09/06/05
95601147 1051
85a5290f 1052 return kTRUE;
1053}
1054
0421c3d1 1055//_____________________________________________________________________________
06c7e392 1056Bool_t AliSimulation::WriteRawData(const char* detectors,
1057 const char* fileName,
67327b72 1058 Bool_t deleteIntermediateFiles,
1059 Bool_t selrawdata)
0421c3d1 1060{
1061// convert the digits to raw data
06c7e392 1062// First DDL raw data files for the given detectors are created.
1063// If a file name is given, the DDL files are then converted to a DATE file.
1064// If deleteIntermediateFiles is true, the DDL raw files are deleted
1065// afterwards.
1066// If the file name has the extension ".root", the DATE file is converted
1067// to a root file.
1068// If deleteIntermediateFiles is true, the DATE file is deleted afterwards.
67327b72 1069// 'selrawdata' flag can be used to enable writing of detectors raw data
1070// accoring to the trigger cluster.
0421c3d1 1071
87932dab 1072 AliCodeTimerAuto("")
0421c3d1 1073
06c7e392 1074 if (!WriteRawFiles(detectors)) {
1075 if (fStopOnError) return kFALSE;
1076 }
1077
1078 TString dateFileName(fileName);
1079 if (!dateFileName.IsNull()) {
1080 Bool_t rootOutput = dateFileName.EndsWith(".root");
1081 if (rootOutput) dateFileName += ".date";
67327b72 1082 TString selDateFileName;
1083 if (selrawdata) {
1084 selDateFileName = "selected.";
1085 selDateFileName+= dateFileName;
1086 }
1087 if (!ConvertRawFilesToDate(dateFileName,selDateFileName)) {
06c7e392 1088 if (fStopOnError) return kFALSE;
1089 }
1090 if (deleteIntermediateFiles) {
1091 AliRunLoader* runLoader = LoadRun("READ");
1092 if (runLoader) for (Int_t iEvent = 0;
1093 iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
1094 char command[256];
1095 sprintf(command, "rm -r raw%d", iEvent);
1096 gSystem->Exec(command);
1097 }
1098 }
1099
1100 if (rootOutput) {
1101 if (!ConvertDateToRoot(dateFileName, fileName)) {
1102 if (fStopOnError) return kFALSE;
1103 }
1104 if (deleteIntermediateFiles) {
1105 gSystem->Unlink(dateFileName);
1106 }
67327b72 1107 if (selrawdata) {
1108 TString selFileName = "selected.";
1109 selFileName += fileName;
1110 if (!ConvertDateToRoot(selDateFileName, selFileName)) {
1111 if (fStopOnError) return kFALSE;
1112 }
1113 if (deleteIntermediateFiles) {
1114 gSystem->Unlink(selDateFileName);
1115 }
1116 }
06c7e392 1117 }
1118 }
1119
06c7e392 1120 return kTRUE;
1121}
1122
1123//_____________________________________________________________________________
1124Bool_t AliSimulation::WriteRawFiles(const char* detectors)
1125{
1126// convert the digits to raw data DDL files
1127
87932dab 1128 AliCodeTimerAuto("")
1129
06c7e392 1130 AliRunLoader* runLoader = LoadRun("READ");
0421c3d1 1131 if (!runLoader) return kFALSE;
1132
06c7e392 1133 // write raw data to DDL files
0421c3d1 1134 for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
ac1671c0 1135 AliInfo(Form("processing event %d", iEvent));
0421c3d1 1136 runLoader->GetEvent(iEvent);
1137 TString baseDir = gSystem->WorkingDirectory();
1138 char dirName[256];
1139 sprintf(dirName, "raw%d", iEvent);
1140 gSystem->MakeDirectory(dirName);
1141 if (!gSystem->ChangeDirectory(dirName)) {
ac1671c0 1142 AliError(Form("couldn't change to directory %s", dirName));
0421c3d1 1143 if (fStopOnError) return kFALSE; else continue;
1144 }
1145
1146 TString detStr = detectors;
1147 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1148 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1149 AliModule* det = (AliModule*) detArray->At(iDet);
1150 if (!det || !det->IsActive()) continue;
1151 if (IsSelected(det->GetName(), detStr)) {
ac1671c0 1152 AliInfo(Form("creating raw data from digits for %s", det->GetName()));
0421c3d1 1153 det->Digits2Raw();
1154 }
1155 }
1156
007155cc 1157 if (!WriteTriggerRawData())
1158 if (fStopOnError) return kFALSE;
1159
0421c3d1 1160 gSystem->ChangeDirectory(baseDir);
1161 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
ac1671c0 1162 AliError(Form("the following detectors were not found: %s",
1163 detStr.Data()));
0421c3d1 1164 if (fStopOnError) return kFALSE;
1165 }
1166 }
1167
1168 delete runLoader;
87932dab 1169
06c7e392 1170 return kTRUE;
1171}
0421c3d1 1172
06c7e392 1173//_____________________________________________________________________________
67327b72 1174Bool_t AliSimulation::ConvertRawFilesToDate(const char* dateFileName,
1175 const char* selDateFileName)
06c7e392 1176{
1177// convert raw data DDL files to a DATE file with the program "dateStream"
67327b72 1178// The second argument is not empty when the user decides to write
1179// the detectors raw data according to the trigger cluster.
06c7e392 1180
87932dab 1181 AliCodeTimerAuto("")
1182
06c7e392 1183 char* path = gSystem->Which(gSystem->Getenv("PATH"), "dateStream");
1184 if (!path) {
ac1671c0 1185 AliError("the program dateStream was not found");
06c7e392 1186 if (fStopOnError) return kFALSE;
1187 } else {
1188 delete[] path;
1189 }
0421c3d1 1190
06c7e392 1191 AliRunLoader* runLoader = LoadRun("READ");
1192 if (!runLoader) return kFALSE;
1193
ac1671c0 1194 AliInfo(Form("converting raw data DDL files to DATE file %s", dateFileName));
67327b72 1195 Bool_t selrawdata = kFALSE;
1196 if (strcmp(selDateFileName,"") != 0) selrawdata = kTRUE;
1197
06c7e392 1198 char command[256];
f28a8d2d 1199 // Note the option -s. It is used in order to avoid
1200 // the generation of SOR/EOR events.
f86775a3 1201 sprintf(command, "dateStream -c -s -D -o %s -# %d -C -run %d",
5c0fd670 1202 dateFileName, runLoader->GetNumberOfEvents(),runLoader->GetHeader()->GetRun());
06c7e392 1203 FILE* pipe = gSystem->OpenPipe(command, "w");
1204
67327b72 1205 Int_t selEvents = 0;
06c7e392 1206 for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
1207 fprintf(pipe, "GDC\n");
1208 Float_t ldc = 0;
1209 Int_t prevLDC = -1;
1210
67327b72 1211 if (selrawdata) {
1212 // Check if the event was triggered by CTP
1213 runLoader->GetEvent(iEvent);
1214 if (!runLoader->LoadTrigger()) {
1215 AliCentralTrigger *aCTP = runLoader->GetTrigger();
1216 if (aCTP->GetClassMask()) selEvents++;
1217 }
1218 else {
1219 AliWarning("No trigger can be loaded! Writing of selected raw data is abandoned !");
1220 selrawdata = kFALSE;
1221 }
1222 }
1223
06c7e392 1224 // loop over detectors and DDLs
362c9d61 1225 for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
1226 for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls(iDet); iDDL++) {
06c7e392 1227
362c9d61 1228 Int_t ddlID = AliDAQ::DdlID(iDet,iDDL);
06c7e392 1229 Int_t ldcID = Int_t(ldc + 0.0001);
362c9d61 1230 ldc += AliDAQ::NumberOfLdcs(iDet) / AliDAQ::NumberOfDdls(iDet);
06c7e392 1231
1232 char rawFileName[256];
362c9d61 1233 sprintf(rawFileName, "raw%d/%s",
1234 iEvent, AliDAQ::DdlFileName(iDet,iDDL));
06c7e392 1235
1236 // check existence and size of raw data file
1237 FILE* file = fopen(rawFileName, "rb");
1238 if (!file) continue;
1239 fseek(file, 0, SEEK_END);
1240 unsigned long size = ftell(file);
aa04f81b 1241 fclose(file);
1242 if (!size) continue;
06c7e392 1243
1244 if (ldcID != prevLDC) {
1245 fprintf(pipe, " LDC Id %d\n", ldcID);
1246 prevLDC = ldcID;
1247 }
1248 fprintf(pipe, " Equipment Id %d Payload %s\n", ddlID, rawFileName);
1249 }
1250 }
1251 }
1252
1253 Int_t result = gSystem->ClosePipe(pipe);
1254
cf30933c 1255 if (!(selrawdata && selEvents > 0)) {
67327b72 1256 delete runLoader;
1257 return (result == 0);
1258 }
1259
1260 AliInfo(Form("converting selected by trigger cluster raw data DDL files to DATE file %s", selDateFileName));
1261
1262 sprintf(command, "dateStream -c -s -D -o %s -# %d -C -run %d",
1263 selDateFileName,selEvents,runLoader->GetHeader()->GetRun());
1264 FILE* pipe2 = gSystem->OpenPipe(command, "w");
1265
1266 for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
1267
1268 // Get the trigger decision and cluster
1269 TString detClust;
1270 runLoader->GetEvent(iEvent);
1271 if (!runLoader->LoadTrigger()) {
1272 AliCentralTrigger *aCTP = runLoader->GetTrigger();
1273 if (aCTP->GetClassMask() == 0) continue;
1274 detClust = aCTP->GetTriggeredDetectors();
1275 AliInfo(Form("List of detectors to be read out: %s",detClust.Data()));
1276 }
1277
1278 fprintf(pipe2, "GDC\n");
1279 Float_t ldc = 0;
1280 Int_t prevLDC = -1;
1281
1282 // loop over detectors and DDLs
1283 for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
1284 // Write only raw data from detectors that
1285 // are contained in the trigger cluster(s)
1286 if (!IsSelected(AliDAQ::DetectorName(iDet),detClust)) continue;
1287
1288 for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls(iDet); iDDL++) {
1289
1290 Int_t ddlID = AliDAQ::DdlID(iDet,iDDL);
1291 Int_t ldcID = Int_t(ldc + 0.0001);
1292 ldc += AliDAQ::NumberOfLdcs(iDet) / AliDAQ::NumberOfDdls(iDet);
1293
1294 char rawFileName[256];
1295 sprintf(rawFileName, "raw%d/%s",
1296 iEvent, AliDAQ::DdlFileName(iDet,iDDL));
1297
1298 // check existence and size of raw data file
1299 FILE* file = fopen(rawFileName, "rb");
1300 if (!file) continue;
1301 fseek(file, 0, SEEK_END);
1302 unsigned long size = ftell(file);
1303 fclose(file);
1304 if (!size) continue;
1305
1306 if (ldcID != prevLDC) {
1307 fprintf(pipe2, " LDC Id %d\n", ldcID);
1308 prevLDC = ldcID;
1309 }
1310 fprintf(pipe2, " Equipment Id %d Payload %s\n", ddlID, rawFileName);
1311 }
1312 }
1313 }
1314
1315 Int_t result2 = gSystem->ClosePipe(pipe2);
1316
06c7e392 1317 delete runLoader;
67327b72 1318 return ((result == 0) && (result2 == 0));
06c7e392 1319}
1320
1321//_____________________________________________________________________________
1322Bool_t AliSimulation::ConvertDateToRoot(const char* dateFileName,
1323 const char* rootFileName)
1324{
1325// convert a DATE file to a root file with the program "alimdc"
1326
1327 // ALIMDC setup
f28a8d2d 1328 const Int_t kDBSize = 2000000000;
c83eb8f4 1329 const Int_t kTagDBSize = 1000000000;
06c7e392 1330 const Bool_t kFilter = kFALSE;
8ec1d12b 1331 const Int_t kCompression = 1;
06c7e392 1332
1333 char* path = gSystem->Which(gSystem->Getenv("PATH"), "alimdc");
1334 if (!path) {
ac1671c0 1335 AliError("the program alimdc was not found");
06c7e392 1336 if (fStopOnError) return kFALSE;
1337 } else {
1338 delete[] path;
1339 }
1340
ac1671c0 1341 AliInfo(Form("converting DATE file %s to root file %s",
1342 dateFileName, rootFileName));
06c7e392 1343
f732bd7d 1344 const char* rawDBFS[2] = { "/tmp/mdc1", "/tmp/mdc2" };
1345 const char* tagDBFS = "/tmp/mdc1/tags";
f732bd7d 1346
1347 // User defined file system locations
1348 if (gSystem->Getenv("ALIMDC_RAWDB1"))
1349 rawDBFS[0] = gSystem->Getenv("ALIMDC_RAWDB1");
1350 if (gSystem->Getenv("ALIMDC_RAWDB2"))
1351 rawDBFS[1] = gSystem->Getenv("ALIMDC_RAWDB2");
1352 if (gSystem->Getenv("ALIMDC_TAGDB"))
1353 tagDBFS = gSystem->Getenv("ALIMDC_TAGDB");
f732bd7d 1354
1355 gSystem->Exec(Form("rm -rf %s",rawDBFS[0]));
1356 gSystem->Exec(Form("rm -rf %s",rawDBFS[1]));
1357 gSystem->Exec(Form("rm -rf %s",tagDBFS));
f732bd7d 1358
1359 gSystem->Exec(Form("mkdir %s",rawDBFS[0]));
1360 gSystem->Exec(Form("mkdir %s",rawDBFS[1]));
1361 gSystem->Exec(Form("mkdir %s",tagDBFS));
f732bd7d 1362
1363 Int_t result = gSystem->Exec(Form("alimdc %d %d %d %d %s",
1364 kDBSize, kTagDBSize, kFilter, kCompression, dateFileName));
1365 gSystem->Exec(Form("mv %s/*.root %s", rawDBFS[0], rootFileName));
1366
1367 gSystem->Exec(Form("rm -rf %s",rawDBFS[0]));
1368 gSystem->Exec(Form("rm -rf %s",rawDBFS[1]));
1369 gSystem->Exec(Form("rm -rf %s",tagDBFS));
06c7e392 1370
1371 return (result == 0);
0421c3d1 1372}
1373
85a5290f 1374
1375//_____________________________________________________________________________
06c7e392 1376AliRunLoader* AliSimulation::LoadRun(const char* mode) const
95601147 1377{
1378// delete existing run loaders, open a new one and load gAlice
1379
1380 while (AliRunLoader::GetRunLoader()) delete AliRunLoader::GetRunLoader();
1381 AliRunLoader* runLoader =
1382 AliRunLoader::Open(fGAliceFileName.Data(),
06c7e392 1383 AliConfig::GetDefaultEventFolderName(), mode);
95601147 1384 if (!runLoader) {
ac1671c0 1385 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
95601147 1386 return NULL;
1387 }
1388 runLoader->LoadgAlice();
795e4a22 1389 runLoader->LoadHeader();
95601147 1390 gAlice = runLoader->GetAliRun();
1391 if (!gAlice) {
ac1671c0 1392 AliError(Form("no gAlice object found in file %s",
1393 fGAliceFileName.Data()));
95601147 1394 return NULL;
1395 }
1396 return runLoader;
1397}
1398
1399//_____________________________________________________________________________
05526d44 1400Int_t AliSimulation::GetNSignalPerBkgrd(Int_t nEvents) const
1401{
1402// get or calculate the number of signal events per background event
1403
1404 if (!fBkgrdFileNames) return 1;
1405 Int_t nBkgrdFiles = fBkgrdFileNames->GetEntriesFast();
1406 if (nBkgrdFiles == 0) return 1;
1407
1408 // get the number of signal events
1409 if (nEvents <= 0) {
1410 AliRunLoader* runLoader =
ca30848f 1411 AliRunLoader::Open(fGAliceFileName.Data(), "SIGNAL");
05526d44 1412 if (!runLoader) return 1;
ca30848f 1413
05526d44 1414 nEvents = runLoader->GetNumberOfEvents();
1415 delete runLoader;
1416 }
1417
1418 Int_t result = 0;
1419 for (Int_t iBkgrdFile = 0; iBkgrdFile < nBkgrdFiles; iBkgrdFile++) {
1420 // get the number of background events
1421 const char* fileName = ((TObjString*)
1422 (fBkgrdFileNames->At(iBkgrdFile)))->GetName();
ca30848f 1423 AliRunLoader* runLoader =
05526d44 1424 AliRunLoader::Open(fileName, "BKGRD");
1425 if (!runLoader) continue;
1426 Int_t nBkgrdEvents = runLoader->GetNumberOfEvents();
1427 delete runLoader;
ca30848f 1428
05526d44 1429 // get or calculate the number of signal per background events
1430 Int_t nSignalPerBkgrd = fBkgrdFileNames->At(iBkgrdFile)->GetUniqueID();
1431 if (nSignalPerBkgrd <= 0) {
1432 nSignalPerBkgrd = (nEvents-1) / nBkgrdEvents + 1;
1433 } else if (result && (result != nSignalPerBkgrd)) {
ac1671c0 1434 AliInfo(Form("the number of signal events per background event "
1435 "will be changed from %d to %d for stream %d",
1436 nSignalPerBkgrd, result, iBkgrdFile+1));
05526d44 1437 nSignalPerBkgrd = result;
1438 }
1439
1440 if (!result) result = nSignalPerBkgrd;
1441 if (nSignalPerBkgrd * nBkgrdEvents < nEvents) {
ac1671c0 1442 AliWarning(Form("not enough background events (%d) for %d signal events "
1443 "using %d signal per background events for stream %d",
1444 nBkgrdEvents, nEvents, nSignalPerBkgrd, iBkgrdFile+1));
05526d44 1445 }
1446 }
1447
1448 return result;
1449}
1450
1451//_____________________________________________________________________________
85a5290f 1452Bool_t AliSimulation::IsSelected(TString detName, TString& detectors) const
1453{
1454// check whether detName is contained in detectors
1455// if yes, it is removed from detectors
1456
1457 // check if all detectors are selected
1458 if ((detectors.CompareTo("ALL") == 0) ||
1459 detectors.BeginsWith("ALL ") ||
1460 detectors.EndsWith(" ALL") ||
1461 detectors.Contains(" ALL ")) {
1462 detectors = "ALL";
1463 return kTRUE;
1464 }
1465
1466 // search for the given detector
1467 Bool_t result = kFALSE;
1468 if ((detectors.CompareTo(detName) == 0) ||
1469 detectors.BeginsWith(detName+" ") ||
1470 detectors.EndsWith(" "+detName) ||
1471 detectors.Contains(" "+detName+" ")) {
1472 detectors.ReplaceAll(detName, "");
1473 result = kTRUE;
1474 }
1475
1476 // clean up the detectors string
1477 while (detectors.Contains(" ")) detectors.ReplaceAll(" ", " ");
1478 while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
1479 while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
1480
1481 return result;
1482}
ca30848f 1483
795e4a22 1484//_____________________________________________________________________________
ca30848f 1485Bool_t AliSimulation::ConvertRaw2SDigits(const char* rawDirectory, const char* esdFileName)
1486{
1487//
1488// Steering routine to convert raw data in directory rawDirectory/ to fake SDigits.
1489// These can be used for embedding of MC tracks into RAW data using the standard
1490// merging procedure.
1491//
1492// If an ESD file is given the reconstructed vertex is taken from it and stored in the event header.
1493//
1494 if (!gAlice) {
1495 AliError("no gAlice object. Restart aliroot and try again.");
1496 return kFALSE;
1497 }
1498 if (gAlice->Modules()->GetEntries() > 0) {
1499 AliError("gAlice was already run. Restart aliroot and try again.");
1500 return kFALSE;
1501 }
1502
1503 AliInfo(Form("initializing gAlice with config file %s",fConfigFileName.Data()));
1504 StdoutToAliInfo(StderrToAliError(gAlice->Init(fConfigFileName.Data());););
1505//
1506// Initialize CDB
795e4a22 1507 InitCDB();
1508 //AliCDBManager* man = AliCDBManager::Instance();
1509 //man->SetRun(0); // Should this come from rawdata header ?
ca30848f 1510
1511 Int_t iDet;
1512 //
1513 // Get the runloader
1514 AliRunLoader* runLoader = gAlice->GetRunLoader();
1515 //
1516 // Open esd file if available
1517 TFile* esdFile = TFile::Open(esdFileName);
1518 Bool_t esdOK = (esdFile != 0);
1519 AliESD* esd = new AliESD;
1520 TTree* treeESD = 0;
1521 if (esdOK) {
1522 treeESD = (TTree*) esdFile->Get("esdTree");
1523 if (!treeESD) {
1524 AliWarning("No ESD tree found");
1525 esdOK = kFALSE;
1526 } else {
1527 treeESD->SetBranchAddress("ESD", &esd);
1528 }
1529 }
1530 //
1531 // Create the RawReader
8b31e840 1532 TString fileName(rawDirectory);
1533 AliRawReader* rawReader = 0x0;
1534 if (fileName.EndsWith("/")) {
1535 rawReader = new AliRawReaderFile(fileName);
1536 } else if (fileName.EndsWith(".root")) {
1537 rawReader = new AliRawReaderRoot(fileName);
1538 } else if (!fileName.IsNull()) {
1539 rawReader = new AliRawReaderDate(fileName);
1540 rawReader->SelectEvents(7);
1541 }
1542// if (!fEquipIdMap.IsNull() && fRawReader)
1543// fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
ca30848f 1544 //
1545 // Get list of detectors
1546 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1547 //
1548 // Get Header
1549 AliHeader* header = runLoader->GetHeader();
1550 //
8b31e840 1551 TString detStr = fMakeSDigits;
ca30848f 1552 // Event loop
1553 Int_t nev = 0;
1554 while(kTRUE) {
1555 if (!(rawReader->NextEvent())) break;
1556 //
1557 // Detector loop
1558 for (iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1559 AliModule* det = (AliModule*) detArray->At(iDet);
8b31e840 1560 if (!det || !det->IsActive()) continue;
1561 if (IsSelected(det->GetName(), detStr)) {
1562 AliInfo(Form("Calling Raw2SDigits for %s\n", det->GetName()));
1563 det->Raw2SDigits(rawReader);
1564 rawReader->Reset();
1565 }
ca30848f 1566 } // detectors
1567
5b188f2f 1568
ca30848f 1569 //
1570 // If ESD information available obtain reconstructed vertex and store in header.
1571 if (esdOK) {
1572 treeESD->GetEvent(nev);
1573 const AliESDVertex* esdVertex = esd->GetPrimaryVertex();
1574 Double_t position[3];
1575 esdVertex->GetXYZ(position);
1576 AliGenEventHeader* mcHeader = new AliGenEventHeader("ESD");
1577 TArrayF mcV;
1578 mcV.Set(3);
1579 for (Int_t i = 0; i < 3; i++) mcV[i] = position[i];
1580 mcHeader->SetPrimaryVertex(mcV);
1581 header->Reset(0,nev);
1582 header->SetGenEventHeader(mcHeader);
1583 printf("***** Saved vertex %f %f %f \n", position[0], position[1], position[2]);
1584 }
1585 nev++;
1586//
1587// Finish the event
1588 runLoader->TreeE()->Fill();
1589 runLoader->SetNextEvent();
1590 } // events
1591
1592 delete rawReader;
1593//
1594// Finish the run
1595 runLoader->CdGAFile();
1596 runLoader->WriteHeader("OVERWRITE");
1597 runLoader->WriteRunLoader();
1598
1599 return kTRUE;
1600}
5b188f2f 1601
1602//_____________________________________________________________________________
1603Int_t AliSimulation::GetDetIndex(const char* detector)
1604{
1605 // return the detector index corresponding to detector
1606 Int_t index = -1 ;
1607 for (index = 0; index < fgkNDetectors ; index++) {
1608 if ( strcmp(detector, fgkDetectorName[index]) == 0 )
1609 break ;
1610 }
1611 return index ;
1612}
cae21299 1613
1614//_____________________________________________________________________________
1615Bool_t AliSimulation::RunHLT()
1616{
1617 // Run the HLT simulation
1618 // HLT simulation is implemented in HLT/sim/AliHLTSimulation
1619 // Disabled if fRunHLT is empty, default vaule is "default".
1620 // AliSimulation::SetRunHLT can be used to set the options for HLT simulation
1621 // The default simulation depends on the HLT component libraries and their
1622 // corresponding agents which define components and chains to run. See
1623 // http://web.ift.uib.no/~kjeks/doc/alice-hlt/
1624 // http://web.ift.uib.no/~kjeks/doc/alice-hlt/classAliHLTModuleAgent.html
1625 //
1626 // The libraries to be loaded can be specified as an option.
1627 // <pre>
1628 // AliSimulation sim;
1629 // sim.SetRunHLT("libAliHLTSample.so");
1630 // </pre>
1631 // will only load <tt>libAliHLTSample.so</tt>
1632
1633 // Other available options:
1634 // \li loglevel=<i>level</i> <br>
1635 // logging level for this processing
1636 // \li alilog=off
1637 // disable redirection of log messages to AliLog class
1638 // \li config=<i>macro</i>
1639 // configuration macro
1640 // \li localrec=<i>configuration</i>
1641 // comma separated list of configurations to be run during simulation
1642
1643 int iResult=0;
1644 AliRunLoader* pRunLoader = LoadRun("READ");
1645 if (!pRunLoader) return kFALSE;
1646
795e4a22 1647 // initialize CDB storage, run number, set CDB lock
1648 InitCDB();
1649 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
1650 SetCDBLock();
1651
cae21299 1652 // load the library dynamically
1653 gSystem->Load(ALIHLTSIMULATION_LIBRARY);
1654
1655 // check for the library version
1656 AliHLTSimulationGetLibraryVersion_t fctVersion=(AliHLTSimulationGetLibraryVersion_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_GET_LIBRARY_VERSION));
1657 if (!fctVersion) {
1658 AliError(Form("can not load library %s", ALIHLTSIMULATION_LIBRARY));
1659 return kFALSE;
1660 }
1661 if (fctVersion()!= ALIHLTSIMULATION_LIBRARY_VERSION) {
1662 AliError(Form("%s version does not match: compiled for version %d, loaded %d", ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_LIBRARY_VERSION, fctVersion()));
1663 return kFALSE;
1664 }
1665
1666 // print compile info
1667 typedef void (*CompileInfo)( char*& date, char*& time);
1668 CompileInfo fctInfo=(CompileInfo)gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, "CompileInfo");
1669 if (fctInfo) {
1670 char* date="";
1671 char* time="";
1672 (*fctInfo)(date, time);
1673 if (!date) date="unknown";
1674 if (!time) time="unknown";
1675 AliInfo(Form("%s build on %s (%s)", ALIHLTSIMULATION_LIBRARY, date, time));
1676 } else {
1677 AliInfo(Form("no build info available for %s", ALIHLTSIMULATION_LIBRARY));
1678 }
1679
1680 // create instance of the HLT simulation
1681 AliHLTSimulationCreateInstance_t fctCreate=(AliHLTSimulationCreateInstance_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_CREATE_INSTANCE));
1682 AliHLTSimulation* pHLT=NULL;
1683 if (fctCreate==NULL || (pHLT=(fctCreate()))==NULL) {
1684 AliError(Form("can not create instance of HLT simulation (creator %p)", fctCreate));
1685 return kFALSE;
1686 }
1687
1688 // init the HLT simulation
1689 if (fRunHLT.CompareTo("default")==0) fRunHLT="";
1690 AliHLTSimulationInit_t fctInit=(AliHLTSimulationInit_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_INIT));
1691 if (fctInit==NULL || (iResult=(fctInit(pHLT, pRunLoader, fRunHLT.Data())))<0) {
1692 AliError(Form("can not init HLT simulation: error %d (init %p)", iResult, fctInit));
1693 } else {
1694 // run the HLT simulation
1695 AliHLTSimulationRun_t fctRun=(AliHLTSimulationRun_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_RUN));
1696 if (fctRun==NULL || (iResult=(fctRun(pHLT, pRunLoader)))<0) {
1697 AliError(Form("can not run HLT simulation: error %d (run %p)", iResult, fctRun));
1698 }
1699 }
1700
1701 // delete the instance
1702 AliHLTSimulationDeleteInstance_t fctDelete=(AliHLTSimulationDeleteInstance_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_DELETE_INSTANCE));
1703 if (fctDelete==NULL || fctDelete(pHLT)<0) {
1704 AliError(Form("can not delete instance of HLT simulation (creator %p)", fctDelete));
1705 }
1706 pHLT=NULL;
1707
1708 return iResult>=0?kTRUE:kFALSE;
1709}
cae17938 1710
1711//_____________________________________________________________________________
a1b90a73 1712Bool_t AliSimulation::RunQA()
cae17938 1713{
a1b90a73 1714 // run the QA on summable hits, digits or digits
1715
1716 AliQADataMakerSteer qas ;
1717 qas.SetRunLoader(gAlice->GetRunLoader()) ;
1718
1719 Bool_t rv = qas.Run("ALL", AliQA::kHITS) ;
1720// qas.Reset() ;
1721 rv *= qas.Run(fMakeSDigits.Data(), AliQA::kSDIGITS) ;
1722// qas.Reset() ;
1723 rv *= qas.Run(fMakeDigits.Data(), AliQA::kDIGITS) ;
1724// qas.Reset() ;
1725 rv *= qas.Run(fMakeDigitsFromHits.Data(), AliQA::kDIGITS) ;
cae17938 1726
a1b90a73 1727 return rv ;
cae17938 1728}
1729
795e4a22 1730//_____________________________________________________________________________
1731void AliSimulation::ProcessEnvironmentVars()
1732{
1733// Extract run number and random generator seed from env variables
1734
1735 AliInfo("Processing environment variables");
1736
1737 // Random Number seed
1738
1739 // first check that seed is not already set
1740 if (fSeed == 0) {
1741 if (gSystem->Getenv("CONFIG_SEED")) {
1742 fSeed = atoi(gSystem->Getenv("CONFIG_SEED"));
1743 }
1744 } else {
1745 if (gSystem->Getenv("CONFIG_SEED")) {
1746 AliInfo(Form("Seed for random number generation already set (%d)"
1747 ": CONFIG_SEED variable ignored!", fSeed));
1748 }
1749 }
1750
1751 AliInfo(Form("Seed for random number generation = %d ", fSeed));
1752
1753 // Run Number
1754
1755 // first check that run number is not already set
1756 if(fRun < 0) {
1757 if (gSystem->Getenv("DC_RUN")) {
1758 fRun = atoi(gSystem->Getenv("DC_RUN"));
1759 }
1760 } else {
1761 if (gSystem->Getenv("DC_RUN")) {
1762 AliInfo(Form("Run number already set (%d): DC_RUN variable ignored!", fRun));
1763 }
1764 }
1765
1766 AliInfo(Form("Run number = %d", fRun));
1767}