QA local OCDB
[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");
ff5970a3 643
644// // Check that the consistency of symbolic names for the activated subdetectors
645// // in the geometry loaded by AliGeomManager
646// AliRunLoader* runLoader = LoadRun("READ");
647// if (!runLoader) return kFALSE;
648//
649// TString detsToBeChecked = "";
650// TObjArray* detArray = runLoader->GetAliRun()->Detectors();
651// for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
652// AliModule* det = (AliModule*) detArray->At(iDet);
653// if (!det || !det->IsActive()) continue;
654// detsToBeChecked += det->GetName();
655// detsToBeChecked += " ";
656// } // end loop over detectors
657// if(!AliGeomManager::CheckSymNamesLUT(detsToBeChecked.Data()))
658 if(!AliGeomManager::CheckSymNamesLUT("ALL"))
0bf7aade 659 AliFatalClass("Current loaded geometry differs in the definition of symbolic names!");
ff5970a3 660
74ae4297 661 if (!AliGeomManager::GetGeometry()) if (fStopOnError) return kFALSE;
662 // Misalign geometry
25be1e5c 663 if(!MisalignGeometry()) if (fStopOnError) return kFALSE;
6bae477a 664 }
25be1e5c 665
27fc67fa 666
85a5290f 667 // hits -> summable digits
27fc67fa 668 AliSysInfo::AddStamp("Start_sdigitization");
85a5290f 669 if (!fMakeSDigits.IsNull()) {
670 if (!RunSDigitization(fMakeSDigits)) if (fStopOnError) return kFALSE;
a1b90a73 671
85a5290f 672 }
27fc67fa 673 AliSysInfo::AddStamp("Stop_sdigitization");
c65c502a 674
27fc67fa 675 AliSysInfo::AddStamp("Start_digitization");
795e4a22 676 // summable digits -> digits
85a5290f 677 if (!fMakeDigits.IsNull()) {
678 if (!RunDigitization(fMakeDigits, fMakeDigitsFromHits)) {
679 if (fStopOnError) return kFALSE;
680 }
a1b90a73 681 }
27fc67fa 682 AliSysInfo::AddStamp("Stop_digitization");
85a5290f 683
795e4a22 684
685
85a5290f 686 // hits -> digits
687 if (!fMakeDigitsFromHits.IsNull()) {
95601147 688 if (fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
ac1671c0 689 AliWarning(Form("Merging and direct creation of digits from hits "
690 "was selected for some detectors. "
691 "No merging will be done for the following detectors: %s",
692 fMakeDigitsFromHits.Data()));
85a5290f 693 }
694 if (!RunHitsDigitization(fMakeDigitsFromHits)) {
695 if (fStopOnError) return kFALSE;
696 }
697 }
698
795e4a22 699
700
a5a091ce 701 // digits -> trigger
8480396b 702 if (!RunTrigger(fMakeTrigger,fMakeDigits)) {
087426de 703 if (fStopOnError) return kFALSE;
a5a091ce 704 }
705
795e4a22 706
707
0421c3d1 708 // digits -> raw data
709 if (!fWriteRawData.IsNull()) {
06c7e392 710 if (!WriteRawData(fWriteRawData, fRawDataFileName,
67327b72 711 fDeleteIntermediateFiles,fWriteSelRawData)) {
0421c3d1 712 if (fStopOnError) return kFALSE;
713 }
714 }
715
795e4a22 716
717
cae21299 718 // run HLT simulation
719 if (!fRunHLT.IsNull()) {
720 if (!RunHLT()) {
721 if (fStopOnError) return kFALSE;
722 }
723 }
795e4a22 724
04236e67 725 //QA
726 if (fRunQA) {
727 Bool_t rv = RunQA() ;
728 if (!rv)
729 if (fStopOnError)
730 return kFALSE ;
731 }
795e4a22 732
733 // Cleanup of CDB manager: cache and active storages!
734 AliCDBManager::Instance()->ClearCache();
735
85a5290f 736 return kTRUE;
737}
738
739//_____________________________________________________________________________
8480396b 740Bool_t AliSimulation::RunTrigger(const char* config, const char* detectors)
a5a091ce 741{
742 // run the trigger
743
87932dab 744 AliCodeTimerAuto("")
a5a091ce 745
795e4a22 746 // initialize CDB storage from external environment
747 // (either CDB manager or AliSimulation setters),
748 // if not already done in RunSimulation()
749 InitCDB();
750
751 // Set run number in CDBManager from data
752 // From this point on the run number must be always loaded from data!
753 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
754
755 // Set CDB lock: from now on it is forbidden to reset the run number
756 // or the default storage or to activate any further storage!
757 SetCDBLock();
758
bacbe0fd 759 AliRunLoader* runLoader = LoadRun("READ");
760 if (!runLoader) return kFALSE;
51f6d619 761 TString trconfiguration = config;
bacbe0fd 762
51f6d619 763 if (trconfiguration.IsNull()) {
087426de 764 if (gAlice->GetTriggerDescriptor() != "") {
51f6d619 765 trconfiguration = gAlice->GetTriggerDescriptor();
087426de 766 }
51f6d619 767 else
8480396b 768 AliWarning("No trigger descriptor is specified. Loading the one that is in the CDB.");
087426de 769 }
770
0f46f5fa 771 runLoader->MakeTree( "GG" );
bacbe0fd 772 AliCentralTrigger* aCTP = runLoader->GetTrigger();
51f6d619 773 // Load Configuration
774 if (!aCTP->LoadConfiguration( trconfiguration ))
775 return kFALSE;
a5a091ce 776
51f6d619 777 // digits -> trigger
8480396b 778 if( !aCTP->RunTrigger( runLoader , detectors ) ) {
a5a091ce 779 if (fStopOnError) {
51f6d619 780 // delete aCTP;
781 return kFALSE;
a5a091ce 782 }
bacbe0fd 783 }
a5a091ce 784
bacbe0fd 785 delete runLoader;
a5a091ce 786
bacbe0fd 787 return kTRUE;
a5a091ce 788}
789
007155cc 790//_____________________________________________________________________________
791Bool_t AliSimulation::WriteTriggerRawData()
792{
793 // Writes the CTP (trigger) DDL raw data
794 // Details of the format are given in the
795 // trigger TDR - pages 134 and 135.
796 AliCTPRawData writer;
797 writer.RawData();
a5a091ce 798
007155cc 799 return kTRUE;
800}
a5a091ce 801
802//_____________________________________________________________________________
95601147 803Bool_t AliSimulation::RunSimulation(Int_t nEvents)
85a5290f 804{
805// run the generation and simulation
806
87932dab 807 AliCodeTimerAuto("")
4df28b43 808
795e4a22 809 // initialize CDB storage and run number from external environment
810 // (either CDB manager or AliSimulation setters)
811 InitCDB();
812 InitRunNumber();
813 SetCDBLock();
814
95601147 815 if (!gAlice) {
ac1671c0 816 AliError("no gAlice object. Restart aliroot and try again.");
95601147 817 return kFALSE;
818 }
819 if (gAlice->Modules()->GetEntries() > 0) {
ac1671c0 820 AliError("gAlice was already run. Restart aliroot and try again.");
95601147 821 return kFALSE;
822 }
823
ac1671c0 824 AliInfo(Form("initializing gAlice with config file %s",
825 fConfigFileName.Data()));
815c2b38 826 StdoutToAliInfo(StderrToAliError(
827 gAlice->Init(fConfigFileName.Data());
828 ););
795e4a22 829
087426de 830 // Get the trigger descriptor string
831 // Either from AliSimulation or from
832 // gAlice
833 if (fMakeTrigger.IsNull()) {
834 if (gAlice->GetTriggerDescriptor() != "")
835 fMakeTrigger = gAlice->GetTriggerDescriptor();
836 }
837 else
838 gAlice->SetTriggerDescriptor(fMakeTrigger.Data());
839
6bae477a 840 // Set run number in CDBManager
024cf675 841 AliInfo(Form("Run number: %d",AliCDBManager::Instance()->GetRun()));
842
843 AliRunLoader* runLoader = gAlice->GetRunLoader();
844 if (!runLoader) {
845 AliError(Form("gAlice has no run loader object. "
846 "Check your config file: %s", fConfigFileName.Data()));
847 return kFALSE;
848 }
849 SetGAliceFile(runLoader->GetFileName());
795e4a22 850
6bae477a 851 // Misalign geometry
caf9c464 852#if ROOT_VERSION_CODE < 331527
74ae4297 853 AliGeomManager::SetGeometry(gGeoManager);
ff5970a3 854
855 // Check that the consistency of symbolic names for the activated subdetectors
856 // in the geometry loaded by AliGeomManager
857 TString detsToBeChecked = "";
858 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
859 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
860 AliModule* det = (AliModule*) detArray->At(iDet);
861 if (!det || !det->IsActive()) continue;
862 detsToBeChecked += det->GetName();
863 detsToBeChecked += " ";
864 } // end loop over detectors
865 if(!AliGeomManager::CheckSymNamesLUT(detsToBeChecked.Data()))
0bf7aade 866 AliFatalClass("Current loaded geometry differs in the definition of symbolic names!");
caf9c464 867 MisalignGeometry(runLoader);
868#endif
995ad051 869
024cf675 870// AliRunLoader* runLoader = gAlice->GetRunLoader();
871// if (!runLoader) {
872// AliError(Form("gAlice has no run loader object. "
873// "Check your config file: %s", fConfigFileName.Data()));
874// return kFALSE;
875// }
876// SetGAliceFile(runLoader->GetFileName());
85a5290f 877
04bae0a0 878 if (!gAlice->Generator()) {
ac1671c0 879 AliError(Form("gAlice has no generator object. "
880 "Check your config file: %s", fConfigFileName.Data()));
04bae0a0 881 return kFALSE;
882 }
05526d44 883 if (nEvents <= 0) nEvents = fNEvents;
04bae0a0 884
885 // get vertex from background file in case of merging
886 if (fUseBkgrdVertex &&
887 fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
05526d44 888 Int_t signalPerBkgrd = GetNSignalPerBkgrd(nEvents);
04bae0a0 889 const char* fileName = ((TObjString*)
890 (fBkgrdFileNames->At(0)))->GetName();
ac1671c0 891 AliInfo(Form("The vertex will be taken from the background "
892 "file %s with nSignalPerBackground = %d",
893 fileName, signalPerBkgrd));
04bae0a0 894 AliVertexGenFile* vtxGen = new AliVertexGenFile(fileName, signalPerBkgrd);
895 gAlice->Generator()->SetVertexGenerator(vtxGen);
896 }
897
85a5290f 898 if (!fRunSimulation) {
85a5290f 899 gAlice->Generator()->SetTrackingFlag(0);
900 }
901
18b43626 902 // set the number of events per file for given detectors and data types
903 for (Int_t i = 0; i < fEventsPerFile.GetEntriesFast(); i++) {
904 if (!fEventsPerFile[i]) continue;
905 const char* detName = fEventsPerFile[i]->GetName();
906 const char* typeName = fEventsPerFile[i]->GetTitle();
907 TString loaderName(detName);
908 loaderName += "Loader";
909 AliLoader* loader = runLoader->GetLoader(loaderName);
910 if (!loader) {
ac1671c0 911 AliError(Form("RunSimulation", "no loader for %s found\n"
912 "Number of events per file not set for %s %s",
913 detName, typeName, detName));
18b43626 914 continue;
915 }
916 AliDataLoader* dataLoader =
917 loader->GetDataLoader(typeName);
918 if (!dataLoader) {
ac1671c0 919 AliError(Form("no data loader for %s found\n"
920 "Number of events per file not set for %s %s",
921 typeName, detName, typeName));
18b43626 922 continue;
923 }
924 dataLoader->SetNumberOfEventsPerFile(fEventsPerFile[i]->GetUniqueID());
ac1671c0 925 AliDebug(1, Form("number of events per file set to %d for %s %s",
926 fEventsPerFile[i]->GetUniqueID(), detName, typeName));
18b43626 927 }
928
ac1671c0 929 AliInfo("running gAlice");
27fc67fa 930 AliSysInfo::AddStamp("Start_simulation");
815c2b38 931 StdoutToAliInfo(StderrToAliError(
932 gAlice->Run(nEvents);
933 ););
27fc67fa 934 AliSysInfo::AddStamp("Stop_simulation");
95601147 935 delete runLoader;
85a5290f 936
937 return kTRUE;
938}
939
940//_____________________________________________________________________________
95601147 941Bool_t AliSimulation::RunSDigitization(const char* detectors)
85a5290f 942{
943// run the digitization and produce summable digits
27fc67fa 944 static Int_t eventNr=0;
87932dab 945 AliCodeTimerAuto("")
4df28b43 946
795e4a22 947 // initialize CDB storage, run number, set CDB lock
948 InitCDB();
949 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
950 SetCDBLock();
951
95601147 952 AliRunLoader* runLoader = LoadRun();
953 if (!runLoader) return kFALSE;
954
85a5290f 955 TString detStr = detectors;
95601147 956 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
85a5290f 957 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
958 AliModule* det = (AliModule*) detArray->At(iDet);
959 if (!det || !det->IsActive()) continue;
960 if (IsSelected(det->GetName(), detStr)) {
ac1671c0 961 AliInfo(Form("creating summable digits for %s", det->GetName()));
87932dab 962 AliCodeTimerAuto(Form("creating summable digits for %s", det->GetName()));
85a5290f 963 det->Hits2SDigits();
27fc67fa 964 AliSysInfo::AddStamp(Form("Digit_%s_%d",det->GetName(),eventNr), 0,1, eventNr);
85a5290f 965 }
966 }
967
968 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
ac1671c0 969 AliError(Form("the following detectors were not found: %s",
970 detStr.Data()));
85a5290f 971 if (fStopOnError) return kFALSE;
972 }
27fc67fa 973 eventNr++;
95601147 974 delete runLoader;
975
85a5290f 976 return kTRUE;
977}
978
979
980//_____________________________________________________________________________
95601147 981Bool_t AliSimulation::RunDigitization(const char* detectors,
982 const char* excludeDetectors)
85a5290f 983{
984// run the digitization and produce digits from sdigits
985
87932dab 986 AliCodeTimerAuto("")
4df28b43 987
795e4a22 988 // initialize CDB storage, run number, set CDB lock
989 InitCDB();
990 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
991 SetCDBLock();
992
95601147 993 while (AliRunLoader::GetRunLoader()) delete AliRunLoader::GetRunLoader();
994 if (gAlice) delete gAlice;
995 gAlice = NULL;
996
997 Int_t nStreams = 1;
05526d44 998 if (fBkgrdFileNames) nStreams = fBkgrdFileNames->GetEntriesFast() + 1;
999 Int_t signalPerBkgrd = GetNSignalPerBkgrd();
85a5290f 1000 AliRunDigitizer* manager = new AliRunDigitizer(nStreams, signalPerBkgrd);
ca30848f 1001 // manager->SetEmbeddingFlag(fEmbeddingFlag);
85a5290f 1002 manager->SetInputStream(0, fGAliceFileName.Data());
1003 for (Int_t iStream = 1; iStream < nStreams; iStream++) {
1004 const char* fileName = ((TObjString*)
1005 (fBkgrdFileNames->At(iStream-1)))->GetName();
1006 manager->SetInputStream(iStream, fileName);
1007 }
1008
1009 TString detStr = detectors;
1010 TString detExcl = excludeDetectors;
95601147 1011 manager->GetInputStream(0)->ImportgAlice();
1012 AliRunLoader* runLoader =
1013 AliRunLoader::GetRunLoader(manager->GetInputStream(0)->GetFolderName());
1014 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
85a5290f 1015 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1016 AliModule* det = (AliModule*) detArray->At(iDet);
1017 if (!det || !det->IsActive()) continue;
1018 if (IsSelected(det->GetName(), detStr) &&
1019 !IsSelected(det->GetName(), detExcl)) {
4df28b43 1020 AliDigitizer* digitizer = det->CreateDigitizer(manager);
ca30848f 1021
4df28b43 1022 if (!digitizer) {
ac1671c0 1023 AliError(Form("no digitizer for %s", det->GetName()));
85a5290f 1024 if (fStopOnError) return kFALSE;
4df28b43 1025 } else {
1026 digitizer->SetRegionOfInterest(fRegionOfInterest);
85a5290f 1027 }
1028 }
1029 }
1030
1031 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
ac1671c0 1032 AliError(Form("the following detectors were not found: %s",
1033 detStr.Data()));
85a5290f 1034 if (fStopOnError) return kFALSE;
1035 }
1036
1037 if (!manager->GetListOfTasks()->IsEmpty()) {
ac1671c0 1038 AliInfo("executing digitization");
85a5290f 1039 manager->Exec("");
1040 }
95601147 1041
85a5290f 1042 delete manager;
1043
1044 return kTRUE;
1045}
1046
1047//_____________________________________________________________________________
95601147 1048Bool_t AliSimulation::RunHitsDigitization(const char* detectors)
85a5290f 1049{
1050// run the digitization and produce digits from hits
1051
87932dab 1052 AliCodeTimerAuto("")
4df28b43 1053
795e4a22 1054 // initialize CDB storage, run number, set CDB lock
1055 InitCDB();
1056 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
1057 SetCDBLock();
1058
591f51bb 1059 AliRunLoader* runLoader = LoadRun("READ");
95601147 1060 if (!runLoader) return kFALSE;
1061
85a5290f 1062 TString detStr = detectors;
95601147 1063 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
85a5290f 1064 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1065 AliModule* det = (AliModule*) detArray->At(iDet);
1066 if (!det || !det->IsActive()) continue;
1067 if (IsSelected(det->GetName(), detStr)) {
ac1671c0 1068 AliInfo(Form("creating digits from hits for %s", det->GetName()));
85a5290f 1069 det->Hits2Digits();
1070 }
1071 }
1072
1073 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
ac1671c0 1074 AliError(Form("the following detectors were not found: %s",
1075 detStr.Data()));
85a5290f 1076 if (fStopOnError) return kFALSE;
1077 }
1078
b17cac0f 1079 delete runLoader;
591f51bb 1080 //PH Temporary fix to avoid interference with the PHOS loder/getter
1081 //PH The problem has to be solved in more general way 09/06/05
95601147 1082
85a5290f 1083 return kTRUE;
1084}
1085
0421c3d1 1086//_____________________________________________________________________________
06c7e392 1087Bool_t AliSimulation::WriteRawData(const char* detectors,
1088 const char* fileName,
67327b72 1089 Bool_t deleteIntermediateFiles,
1090 Bool_t selrawdata)
0421c3d1 1091{
1092// convert the digits to raw data
06c7e392 1093// First DDL raw data files for the given detectors are created.
1094// If a file name is given, the DDL files are then converted to a DATE file.
1095// If deleteIntermediateFiles is true, the DDL raw files are deleted
1096// afterwards.
1097// If the file name has the extension ".root", the DATE file is converted
1098// to a root file.
1099// If deleteIntermediateFiles is true, the DATE file is deleted afterwards.
67327b72 1100// 'selrawdata' flag can be used to enable writing of detectors raw data
1101// accoring to the trigger cluster.
0421c3d1 1102
87932dab 1103 AliCodeTimerAuto("")
0421c3d1 1104
06c7e392 1105 if (!WriteRawFiles(detectors)) {
1106 if (fStopOnError) return kFALSE;
1107 }
1108
1109 TString dateFileName(fileName);
1110 if (!dateFileName.IsNull()) {
1111 Bool_t rootOutput = dateFileName.EndsWith(".root");
1112 if (rootOutput) dateFileName += ".date";
67327b72 1113 TString selDateFileName;
1114 if (selrawdata) {
1115 selDateFileName = "selected.";
1116 selDateFileName+= dateFileName;
1117 }
1118 if (!ConvertRawFilesToDate(dateFileName,selDateFileName)) {
06c7e392 1119 if (fStopOnError) return kFALSE;
1120 }
1121 if (deleteIntermediateFiles) {
1122 AliRunLoader* runLoader = LoadRun("READ");
1123 if (runLoader) for (Int_t iEvent = 0;
1124 iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
1125 char command[256];
1126 sprintf(command, "rm -r raw%d", iEvent);
1127 gSystem->Exec(command);
1128 }
1129 }
1130
1131 if (rootOutput) {
1132 if (!ConvertDateToRoot(dateFileName, fileName)) {
1133 if (fStopOnError) return kFALSE;
1134 }
1135 if (deleteIntermediateFiles) {
1136 gSystem->Unlink(dateFileName);
1137 }
67327b72 1138 if (selrawdata) {
1139 TString selFileName = "selected.";
1140 selFileName += fileName;
1141 if (!ConvertDateToRoot(selDateFileName, selFileName)) {
1142 if (fStopOnError) return kFALSE;
1143 }
1144 if (deleteIntermediateFiles) {
1145 gSystem->Unlink(selDateFileName);
1146 }
1147 }
06c7e392 1148 }
1149 }
1150
06c7e392 1151 return kTRUE;
1152}
1153
1154//_____________________________________________________________________________
1155Bool_t AliSimulation::WriteRawFiles(const char* detectors)
1156{
1157// convert the digits to raw data DDL files
1158
87932dab 1159 AliCodeTimerAuto("")
1160
06c7e392 1161 AliRunLoader* runLoader = LoadRun("READ");
0421c3d1 1162 if (!runLoader) return kFALSE;
1163
06c7e392 1164 // write raw data to DDL files
0421c3d1 1165 for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
ac1671c0 1166 AliInfo(Form("processing event %d", iEvent));
0421c3d1 1167 runLoader->GetEvent(iEvent);
1168 TString baseDir = gSystem->WorkingDirectory();
1169 char dirName[256];
1170 sprintf(dirName, "raw%d", iEvent);
1171 gSystem->MakeDirectory(dirName);
1172 if (!gSystem->ChangeDirectory(dirName)) {
ac1671c0 1173 AliError(Form("couldn't change to directory %s", dirName));
0421c3d1 1174 if (fStopOnError) return kFALSE; else continue;
1175 }
1176
1177 TString detStr = detectors;
1178 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1179 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1180 AliModule* det = (AliModule*) detArray->At(iDet);
1181 if (!det || !det->IsActive()) continue;
1182 if (IsSelected(det->GetName(), detStr)) {
ac1671c0 1183 AliInfo(Form("creating raw data from digits for %s", det->GetName()));
0421c3d1 1184 det->Digits2Raw();
1185 }
1186 }
1187
007155cc 1188 if (!WriteTriggerRawData())
1189 if (fStopOnError) return kFALSE;
1190
0421c3d1 1191 gSystem->ChangeDirectory(baseDir);
1192 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
ac1671c0 1193 AliError(Form("the following detectors were not found: %s",
1194 detStr.Data()));
0421c3d1 1195 if (fStopOnError) return kFALSE;
1196 }
1197 }
1198
1199 delete runLoader;
87932dab 1200
06c7e392 1201 return kTRUE;
1202}
0421c3d1 1203
06c7e392 1204//_____________________________________________________________________________
67327b72 1205Bool_t AliSimulation::ConvertRawFilesToDate(const char* dateFileName,
1206 const char* selDateFileName)
06c7e392 1207{
1208// convert raw data DDL files to a DATE file with the program "dateStream"
67327b72 1209// The second argument is not empty when the user decides to write
1210// the detectors raw data according to the trigger cluster.
06c7e392 1211
87932dab 1212 AliCodeTimerAuto("")
1213
06c7e392 1214 char* path = gSystem->Which(gSystem->Getenv("PATH"), "dateStream");
1215 if (!path) {
ac1671c0 1216 AliError("the program dateStream was not found");
06c7e392 1217 if (fStopOnError) return kFALSE;
1218 } else {
1219 delete[] path;
1220 }
0421c3d1 1221
06c7e392 1222 AliRunLoader* runLoader = LoadRun("READ");
1223 if (!runLoader) return kFALSE;
1224
ac1671c0 1225 AliInfo(Form("converting raw data DDL files to DATE file %s", dateFileName));
67327b72 1226 Bool_t selrawdata = kFALSE;
1227 if (strcmp(selDateFileName,"") != 0) selrawdata = kTRUE;
1228
06c7e392 1229 char command[256];
f28a8d2d 1230 // Note the option -s. It is used in order to avoid
1231 // the generation of SOR/EOR events.
f86775a3 1232 sprintf(command, "dateStream -c -s -D -o %s -# %d -C -run %d",
5c0fd670 1233 dateFileName, runLoader->GetNumberOfEvents(),runLoader->GetHeader()->GetRun());
06c7e392 1234 FILE* pipe = gSystem->OpenPipe(command, "w");
1235
67327b72 1236 Int_t selEvents = 0;
06c7e392 1237 for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
1238 fprintf(pipe, "GDC\n");
1239 Float_t ldc = 0;
1240 Int_t prevLDC = -1;
1241
67327b72 1242 if (selrawdata) {
1243 // Check if the event was triggered by CTP
1244 runLoader->GetEvent(iEvent);
1245 if (!runLoader->LoadTrigger()) {
1246 AliCentralTrigger *aCTP = runLoader->GetTrigger();
1247 if (aCTP->GetClassMask()) selEvents++;
1248 }
1249 else {
1250 AliWarning("No trigger can be loaded! Writing of selected raw data is abandoned !");
1251 selrawdata = kFALSE;
1252 }
1253 }
1254
06c7e392 1255 // loop over detectors and DDLs
362c9d61 1256 for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
1257 for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls(iDet); iDDL++) {
06c7e392 1258
362c9d61 1259 Int_t ddlID = AliDAQ::DdlID(iDet,iDDL);
06c7e392 1260 Int_t ldcID = Int_t(ldc + 0.0001);
362c9d61 1261 ldc += AliDAQ::NumberOfLdcs(iDet) / AliDAQ::NumberOfDdls(iDet);
06c7e392 1262
1263 char rawFileName[256];
362c9d61 1264 sprintf(rawFileName, "raw%d/%s",
1265 iEvent, AliDAQ::DdlFileName(iDet,iDDL));
06c7e392 1266
1267 // check existence and size of raw data file
1268 FILE* file = fopen(rawFileName, "rb");
1269 if (!file) continue;
1270 fseek(file, 0, SEEK_END);
1271 unsigned long size = ftell(file);
aa04f81b 1272 fclose(file);
1273 if (!size) continue;
06c7e392 1274
1275 if (ldcID != prevLDC) {
1276 fprintf(pipe, " LDC Id %d\n", ldcID);
1277 prevLDC = ldcID;
1278 }
1279 fprintf(pipe, " Equipment Id %d Payload %s\n", ddlID, rawFileName);
1280 }
1281 }
1282 }
1283
1284 Int_t result = gSystem->ClosePipe(pipe);
1285
cf30933c 1286 if (!(selrawdata && selEvents > 0)) {
67327b72 1287 delete runLoader;
1288 return (result == 0);
1289 }
1290
1291 AliInfo(Form("converting selected by trigger cluster raw data DDL files to DATE file %s", selDateFileName));
1292
1293 sprintf(command, "dateStream -c -s -D -o %s -# %d -C -run %d",
1294 selDateFileName,selEvents,runLoader->GetHeader()->GetRun());
1295 FILE* pipe2 = gSystem->OpenPipe(command, "w");
1296
1297 for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
1298
1299 // Get the trigger decision and cluster
1300 TString detClust;
1301 runLoader->GetEvent(iEvent);
1302 if (!runLoader->LoadTrigger()) {
1303 AliCentralTrigger *aCTP = runLoader->GetTrigger();
1304 if (aCTP->GetClassMask() == 0) continue;
1305 detClust = aCTP->GetTriggeredDetectors();
1306 AliInfo(Form("List of detectors to be read out: %s",detClust.Data()));
1307 }
1308
1309 fprintf(pipe2, "GDC\n");
1310 Float_t ldc = 0;
1311 Int_t prevLDC = -1;
1312
1313 // loop over detectors and DDLs
1314 for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
1315 // Write only raw data from detectors that
1316 // are contained in the trigger cluster(s)
1317 if (!IsSelected(AliDAQ::DetectorName(iDet),detClust)) continue;
1318
1319 for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls(iDet); iDDL++) {
1320
1321 Int_t ddlID = AliDAQ::DdlID(iDet,iDDL);
1322 Int_t ldcID = Int_t(ldc + 0.0001);
1323 ldc += AliDAQ::NumberOfLdcs(iDet) / AliDAQ::NumberOfDdls(iDet);
1324
1325 char rawFileName[256];
1326 sprintf(rawFileName, "raw%d/%s",
1327 iEvent, AliDAQ::DdlFileName(iDet,iDDL));
1328
1329 // check existence and size of raw data file
1330 FILE* file = fopen(rawFileName, "rb");
1331 if (!file) continue;
1332 fseek(file, 0, SEEK_END);
1333 unsigned long size = ftell(file);
1334 fclose(file);
1335 if (!size) continue;
1336
1337 if (ldcID != prevLDC) {
1338 fprintf(pipe2, " LDC Id %d\n", ldcID);
1339 prevLDC = ldcID;
1340 }
1341 fprintf(pipe2, " Equipment Id %d Payload %s\n", ddlID, rawFileName);
1342 }
1343 }
1344 }
1345
1346 Int_t result2 = gSystem->ClosePipe(pipe2);
1347
06c7e392 1348 delete runLoader;
67327b72 1349 return ((result == 0) && (result2 == 0));
06c7e392 1350}
1351
1352//_____________________________________________________________________________
1353Bool_t AliSimulation::ConvertDateToRoot(const char* dateFileName,
1354 const char* rootFileName)
1355{
1356// convert a DATE file to a root file with the program "alimdc"
1357
1358 // ALIMDC setup
f28a8d2d 1359 const Int_t kDBSize = 2000000000;
c83eb8f4 1360 const Int_t kTagDBSize = 1000000000;
06c7e392 1361 const Bool_t kFilter = kFALSE;
8ec1d12b 1362 const Int_t kCompression = 1;
06c7e392 1363
1364 char* path = gSystem->Which(gSystem->Getenv("PATH"), "alimdc");
1365 if (!path) {
ac1671c0 1366 AliError("the program alimdc was not found");
06c7e392 1367 if (fStopOnError) return kFALSE;
1368 } else {
1369 delete[] path;
1370 }
1371
ac1671c0 1372 AliInfo(Form("converting DATE file %s to root file %s",
1373 dateFileName, rootFileName));
06c7e392 1374
f732bd7d 1375 const char* rawDBFS[2] = { "/tmp/mdc1", "/tmp/mdc2" };
1376 const char* tagDBFS = "/tmp/mdc1/tags";
f732bd7d 1377
1378 // User defined file system locations
1379 if (gSystem->Getenv("ALIMDC_RAWDB1"))
1380 rawDBFS[0] = gSystem->Getenv("ALIMDC_RAWDB1");
1381 if (gSystem->Getenv("ALIMDC_RAWDB2"))
1382 rawDBFS[1] = gSystem->Getenv("ALIMDC_RAWDB2");
1383 if (gSystem->Getenv("ALIMDC_TAGDB"))
1384 tagDBFS = gSystem->Getenv("ALIMDC_TAGDB");
f732bd7d 1385
1386 gSystem->Exec(Form("rm -rf %s",rawDBFS[0]));
1387 gSystem->Exec(Form("rm -rf %s",rawDBFS[1]));
1388 gSystem->Exec(Form("rm -rf %s",tagDBFS));
f732bd7d 1389
1390 gSystem->Exec(Form("mkdir %s",rawDBFS[0]));
1391 gSystem->Exec(Form("mkdir %s",rawDBFS[1]));
1392 gSystem->Exec(Form("mkdir %s",tagDBFS));
f732bd7d 1393
1394 Int_t result = gSystem->Exec(Form("alimdc %d %d %d %d %s",
1395 kDBSize, kTagDBSize, kFilter, kCompression, dateFileName));
1396 gSystem->Exec(Form("mv %s/*.root %s", rawDBFS[0], rootFileName));
1397
1398 gSystem->Exec(Form("rm -rf %s",rawDBFS[0]));
1399 gSystem->Exec(Form("rm -rf %s",rawDBFS[1]));
1400 gSystem->Exec(Form("rm -rf %s",tagDBFS));
06c7e392 1401
1402 return (result == 0);
0421c3d1 1403}
1404
85a5290f 1405
1406//_____________________________________________________________________________
06c7e392 1407AliRunLoader* AliSimulation::LoadRun(const char* mode) const
95601147 1408{
1409// delete existing run loaders, open a new one and load gAlice
1410
1411 while (AliRunLoader::GetRunLoader()) delete AliRunLoader::GetRunLoader();
1412 AliRunLoader* runLoader =
1413 AliRunLoader::Open(fGAliceFileName.Data(),
06c7e392 1414 AliConfig::GetDefaultEventFolderName(), mode);
95601147 1415 if (!runLoader) {
ac1671c0 1416 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
95601147 1417 return NULL;
1418 }
1419 runLoader->LoadgAlice();
795e4a22 1420 runLoader->LoadHeader();
95601147 1421 gAlice = runLoader->GetAliRun();
1422 if (!gAlice) {
ac1671c0 1423 AliError(Form("no gAlice object found in file %s",
1424 fGAliceFileName.Data()));
95601147 1425 return NULL;
1426 }
1427 return runLoader;
1428}
1429
1430//_____________________________________________________________________________
05526d44 1431Int_t AliSimulation::GetNSignalPerBkgrd(Int_t nEvents) const
1432{
1433// get or calculate the number of signal events per background event
1434
1435 if (!fBkgrdFileNames) return 1;
1436 Int_t nBkgrdFiles = fBkgrdFileNames->GetEntriesFast();
1437 if (nBkgrdFiles == 0) return 1;
1438
1439 // get the number of signal events
1440 if (nEvents <= 0) {
1441 AliRunLoader* runLoader =
ca30848f 1442 AliRunLoader::Open(fGAliceFileName.Data(), "SIGNAL");
05526d44 1443 if (!runLoader) return 1;
ca30848f 1444
05526d44 1445 nEvents = runLoader->GetNumberOfEvents();
1446 delete runLoader;
1447 }
1448
1449 Int_t result = 0;
1450 for (Int_t iBkgrdFile = 0; iBkgrdFile < nBkgrdFiles; iBkgrdFile++) {
1451 // get the number of background events
1452 const char* fileName = ((TObjString*)
1453 (fBkgrdFileNames->At(iBkgrdFile)))->GetName();
ca30848f 1454 AliRunLoader* runLoader =
05526d44 1455 AliRunLoader::Open(fileName, "BKGRD");
1456 if (!runLoader) continue;
1457 Int_t nBkgrdEvents = runLoader->GetNumberOfEvents();
1458 delete runLoader;
ca30848f 1459
05526d44 1460 // get or calculate the number of signal per background events
1461 Int_t nSignalPerBkgrd = fBkgrdFileNames->At(iBkgrdFile)->GetUniqueID();
1462 if (nSignalPerBkgrd <= 0) {
1463 nSignalPerBkgrd = (nEvents-1) / nBkgrdEvents + 1;
1464 } else if (result && (result != nSignalPerBkgrd)) {
ac1671c0 1465 AliInfo(Form("the number of signal events per background event "
1466 "will be changed from %d to %d for stream %d",
1467 nSignalPerBkgrd, result, iBkgrdFile+1));
05526d44 1468 nSignalPerBkgrd = result;
1469 }
1470
1471 if (!result) result = nSignalPerBkgrd;
1472 if (nSignalPerBkgrd * nBkgrdEvents < nEvents) {
ac1671c0 1473 AliWarning(Form("not enough background events (%d) for %d signal events "
1474 "using %d signal per background events for stream %d",
1475 nBkgrdEvents, nEvents, nSignalPerBkgrd, iBkgrdFile+1));
05526d44 1476 }
1477 }
1478
1479 return result;
1480}
1481
1482//_____________________________________________________________________________
85a5290f 1483Bool_t AliSimulation::IsSelected(TString detName, TString& detectors) const
1484{
1485// check whether detName is contained in detectors
1486// if yes, it is removed from detectors
1487
1488 // check if all detectors are selected
1489 if ((detectors.CompareTo("ALL") == 0) ||
1490 detectors.BeginsWith("ALL ") ||
1491 detectors.EndsWith(" ALL") ||
1492 detectors.Contains(" ALL ")) {
1493 detectors = "ALL";
1494 return kTRUE;
1495 }
1496
1497 // search for the given detector
1498 Bool_t result = kFALSE;
1499 if ((detectors.CompareTo(detName) == 0) ||
1500 detectors.BeginsWith(detName+" ") ||
1501 detectors.EndsWith(" "+detName) ||
1502 detectors.Contains(" "+detName+" ")) {
1503 detectors.ReplaceAll(detName, "");
1504 result = kTRUE;
1505 }
1506
1507 // clean up the detectors string
1508 while (detectors.Contains(" ")) detectors.ReplaceAll(" ", " ");
1509 while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
1510 while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
1511
1512 return result;
1513}
ca30848f 1514
795e4a22 1515//_____________________________________________________________________________
ca30848f 1516Bool_t AliSimulation::ConvertRaw2SDigits(const char* rawDirectory, const char* esdFileName)
1517{
1518//
1519// Steering routine to convert raw data in directory rawDirectory/ to fake SDigits.
1520// These can be used for embedding of MC tracks into RAW data using the standard
1521// merging procedure.
1522//
1523// If an ESD file is given the reconstructed vertex is taken from it and stored in the event header.
1524//
1525 if (!gAlice) {
1526 AliError("no gAlice object. Restart aliroot and try again.");
1527 return kFALSE;
1528 }
1529 if (gAlice->Modules()->GetEntries() > 0) {
1530 AliError("gAlice was already run. Restart aliroot and try again.");
1531 return kFALSE;
1532 }
1533
1534 AliInfo(Form("initializing gAlice with config file %s",fConfigFileName.Data()));
1535 StdoutToAliInfo(StderrToAliError(gAlice->Init(fConfigFileName.Data());););
1536//
1537// Initialize CDB
795e4a22 1538 InitCDB();
1539 //AliCDBManager* man = AliCDBManager::Instance();
1540 //man->SetRun(0); // Should this come from rawdata header ?
ca30848f 1541
1542 Int_t iDet;
1543 //
1544 // Get the runloader
1545 AliRunLoader* runLoader = gAlice->GetRunLoader();
1546 //
1547 // Open esd file if available
1548 TFile* esdFile = TFile::Open(esdFileName);
1549 Bool_t esdOK = (esdFile != 0);
1550 AliESD* esd = new AliESD;
1551 TTree* treeESD = 0;
1552 if (esdOK) {
1553 treeESD = (TTree*) esdFile->Get("esdTree");
1554 if (!treeESD) {
1555 AliWarning("No ESD tree found");
1556 esdOK = kFALSE;
1557 } else {
1558 treeESD->SetBranchAddress("ESD", &esd);
1559 }
1560 }
1561 //
1562 // Create the RawReader
8b31e840 1563 TString fileName(rawDirectory);
1564 AliRawReader* rawReader = 0x0;
1565 if (fileName.EndsWith("/")) {
1566 rawReader = new AliRawReaderFile(fileName);
1567 } else if (fileName.EndsWith(".root")) {
1568 rawReader = new AliRawReaderRoot(fileName);
1569 } else if (!fileName.IsNull()) {
1570 rawReader = new AliRawReaderDate(fileName);
1571 rawReader->SelectEvents(7);
1572 }
1573// if (!fEquipIdMap.IsNull() && fRawReader)
1574// fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
ca30848f 1575 //
1576 // Get list of detectors
1577 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1578 //
1579 // Get Header
1580 AliHeader* header = runLoader->GetHeader();
1581 //
8b31e840 1582 TString detStr = fMakeSDigits;
ca30848f 1583 // Event loop
1584 Int_t nev = 0;
1585 while(kTRUE) {
1586 if (!(rawReader->NextEvent())) break;
1587 //
1588 // Detector loop
1589 for (iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1590 AliModule* det = (AliModule*) detArray->At(iDet);
8b31e840 1591 if (!det || !det->IsActive()) continue;
1592 if (IsSelected(det->GetName(), detStr)) {
1593 AliInfo(Form("Calling Raw2SDigits for %s\n", det->GetName()));
1594 det->Raw2SDigits(rawReader);
1595 rawReader->Reset();
1596 }
ca30848f 1597 } // detectors
1598
5b188f2f 1599
ca30848f 1600 //
1601 // If ESD information available obtain reconstructed vertex and store in header.
1602 if (esdOK) {
1603 treeESD->GetEvent(nev);
1604 const AliESDVertex* esdVertex = esd->GetPrimaryVertex();
1605 Double_t position[3];
1606 esdVertex->GetXYZ(position);
1607 AliGenEventHeader* mcHeader = new AliGenEventHeader("ESD");
1608 TArrayF mcV;
1609 mcV.Set(3);
1610 for (Int_t i = 0; i < 3; i++) mcV[i] = position[i];
1611 mcHeader->SetPrimaryVertex(mcV);
1612 header->Reset(0,nev);
1613 header->SetGenEventHeader(mcHeader);
1614 printf("***** Saved vertex %f %f %f \n", position[0], position[1], position[2]);
1615 }
1616 nev++;
1617//
1618// Finish the event
1619 runLoader->TreeE()->Fill();
1620 runLoader->SetNextEvent();
1621 } // events
1622
1623 delete rawReader;
1624//
1625// Finish the run
1626 runLoader->CdGAFile();
1627 runLoader->WriteHeader("OVERWRITE");
1628 runLoader->WriteRunLoader();
1629
1630 return kTRUE;
1631}
5b188f2f 1632
1633//_____________________________________________________________________________
1634Int_t AliSimulation::GetDetIndex(const char* detector)
1635{
1636 // return the detector index corresponding to detector
1637 Int_t index = -1 ;
1638 for (index = 0; index < fgkNDetectors ; index++) {
1639 if ( strcmp(detector, fgkDetectorName[index]) == 0 )
1640 break ;
1641 }
1642 return index ;
1643}
cae21299 1644
1645//_____________________________________________________________________________
1646Bool_t AliSimulation::RunHLT()
1647{
1648 // Run the HLT simulation
1649 // HLT simulation is implemented in HLT/sim/AliHLTSimulation
1650 // Disabled if fRunHLT is empty, default vaule is "default".
1651 // AliSimulation::SetRunHLT can be used to set the options for HLT simulation
1652 // The default simulation depends on the HLT component libraries and their
1653 // corresponding agents which define components and chains to run. See
1654 // http://web.ift.uib.no/~kjeks/doc/alice-hlt/
1655 // http://web.ift.uib.no/~kjeks/doc/alice-hlt/classAliHLTModuleAgent.html
1656 //
1657 // The libraries to be loaded can be specified as an option.
1658 // <pre>
1659 // AliSimulation sim;
1660 // sim.SetRunHLT("libAliHLTSample.so");
1661 // </pre>
1662 // will only load <tt>libAliHLTSample.so</tt>
1663
1664 // Other available options:
1665 // \li loglevel=<i>level</i> <br>
1666 // logging level for this processing
1667 // \li alilog=off
1668 // disable redirection of log messages to AliLog class
1669 // \li config=<i>macro</i>
1670 // configuration macro
1671 // \li localrec=<i>configuration</i>
1672 // comma separated list of configurations to be run during simulation
1673
1674 int iResult=0;
1675 AliRunLoader* pRunLoader = LoadRun("READ");
1676 if (!pRunLoader) return kFALSE;
1677
795e4a22 1678 // initialize CDB storage, run number, set CDB lock
1679 InitCDB();
1680 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
1681 SetCDBLock();
1682
cae21299 1683 // load the library dynamically
1684 gSystem->Load(ALIHLTSIMULATION_LIBRARY);
1685
1686 // check for the library version
1687 AliHLTSimulationGetLibraryVersion_t fctVersion=(AliHLTSimulationGetLibraryVersion_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_GET_LIBRARY_VERSION));
1688 if (!fctVersion) {
1689 AliError(Form("can not load library %s", ALIHLTSIMULATION_LIBRARY));
1690 return kFALSE;
1691 }
1692 if (fctVersion()!= ALIHLTSIMULATION_LIBRARY_VERSION) {
1693 AliError(Form("%s version does not match: compiled for version %d, loaded %d", ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_LIBRARY_VERSION, fctVersion()));
1694 return kFALSE;
1695 }
1696
1697 // print compile info
1698 typedef void (*CompileInfo)( char*& date, char*& time);
1699 CompileInfo fctInfo=(CompileInfo)gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, "CompileInfo");
1700 if (fctInfo) {
1701 char* date="";
1702 char* time="";
1703 (*fctInfo)(date, time);
1704 if (!date) date="unknown";
1705 if (!time) time="unknown";
1706 AliInfo(Form("%s build on %s (%s)", ALIHLTSIMULATION_LIBRARY, date, time));
1707 } else {
1708 AliInfo(Form("no build info available for %s", ALIHLTSIMULATION_LIBRARY));
1709 }
1710
1711 // create instance of the HLT simulation
1712 AliHLTSimulationCreateInstance_t fctCreate=(AliHLTSimulationCreateInstance_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_CREATE_INSTANCE));
1713 AliHLTSimulation* pHLT=NULL;
1714 if (fctCreate==NULL || (pHLT=(fctCreate()))==NULL) {
1715 AliError(Form("can not create instance of HLT simulation (creator %p)", fctCreate));
1716 return kFALSE;
1717 }
1718
1719 // init the HLT simulation
a441bf51 1720 TString options;
1721 if (fRunHLT.CompareTo("default")!=0) options=fRunHLT;
1722 if (!IsSelected("HLT", fWriteRawData)) {
1723 options+=" writerawfiles=";
1724 } else {
1725 options+=" writerawfiles=HLT";
1726 }
cae21299 1727 AliHLTSimulationInit_t fctInit=(AliHLTSimulationInit_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_INIT));
a441bf51 1728 if (fctInit==NULL || (iResult=(fctInit(pHLT, pRunLoader, options.Data())))<0) {
cae21299 1729 AliError(Form("can not init HLT simulation: error %d (init %p)", iResult, fctInit));
1730 } else {
1731 // run the HLT simulation
1732 AliHLTSimulationRun_t fctRun=(AliHLTSimulationRun_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_RUN));
1733 if (fctRun==NULL || (iResult=(fctRun(pHLT, pRunLoader)))<0) {
1734 AliError(Form("can not run HLT simulation: error %d (run %p)", iResult, fctRun));
1735 }
1736 }
1737
1738 // delete the instance
1739 AliHLTSimulationDeleteInstance_t fctDelete=(AliHLTSimulationDeleteInstance_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_DELETE_INSTANCE));
1740 if (fctDelete==NULL || fctDelete(pHLT)<0) {
1741 AliError(Form("can not delete instance of HLT simulation (creator %p)", fctDelete));
1742 }
1743 pHLT=NULL;
1744
1745 return iResult>=0?kTRUE:kFALSE;
1746}
cae17938 1747
1748//_____________________________________________________________________________
a1b90a73 1749Bool_t AliSimulation::RunQA()
cae17938 1750{
a1b90a73 1751 // run the QA on summable hits, digits or digits
1752
1753 AliQADataMakerSteer qas ;
1754 qas.SetRunLoader(gAlice->GetRunLoader()) ;
1755
e5dedfe2 1756 TString detectorsw("") ;
1757 Bool_t rv = kTRUE ;
1758 detectorsw = qas.Run("ALL", AliQA::kHITS) ;
a1b90a73 1759// qas.Reset() ;
e5dedfe2 1760 detectorsw += qas.Run(fMakeSDigits.Data(), AliQA::kSDIGITS) ;
a1b90a73 1761// qas.Reset() ;
e5dedfe2 1762 detectorsw += qas.Run(fMakeDigits.Data(), AliQA::kDIGITS) ;
a1b90a73 1763// qas.Reset() ;
e5dedfe2 1764 detectorsw += qas.Run(fMakeDigitsFromHits.Data(), AliQA::kDIGITS) ;
1765
1766 if ( detectorsw.IsNull() )
1767 rv = kFALSE ;
a1b90a73 1768 return rv ;
cae17938 1769}
1770
795e4a22 1771//_____________________________________________________________________________
1772void AliSimulation::ProcessEnvironmentVars()
1773{
1774// Extract run number and random generator seed from env variables
1775
1776 AliInfo("Processing environment variables");
1777
1778 // Random Number seed
1779
1780 // first check that seed is not already set
1781 if (fSeed == 0) {
1782 if (gSystem->Getenv("CONFIG_SEED")) {
1783 fSeed = atoi(gSystem->Getenv("CONFIG_SEED"));
1784 }
1785 } else {
1786 if (gSystem->Getenv("CONFIG_SEED")) {
1787 AliInfo(Form("Seed for random number generation already set (%d)"
1788 ": CONFIG_SEED variable ignored!", fSeed));
1789 }
1790 }
1791
1792 AliInfo(Form("Seed for random number generation = %d ", fSeed));
1793
1794 // Run Number
1795
1796 // first check that run number is not already set
1797 if(fRun < 0) {
1798 if (gSystem->Getenv("DC_RUN")) {
1799 fRun = atoi(gSystem->Getenv("DC_RUN"));
1800 }
1801 } else {
1802 if (gSystem->Getenv("DC_RUN")) {
1803 AliInfo(Form("Run number already set (%d): DC_RUN variable ignored!", fRun));
1804 }
1805 }
1806
1807 AliInfo(Form("Run number = %d", fRun));
1808}
ff5970a3 1809
1810