moved some files, added generator function to addtask macro
[u/mrichter/AliRoot.git] / STEER / 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
c1c44db3 16/* $Id: AliSimulation.cxx 64623 2013-10-21 13:38:58Z rgrosso $ */
85a5290f 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
3e2e3ece 108#include <TFile.h>
f7a1cc68 109#include <TGeoGlobalMagField.h>
e8d02863 110#include <TGeoManager.h>
85a5290f 111#include <TObjString.h>
fc7e1b1c 112#include <TROOT.h>
3e2e3ece 113#include <TSystem.h>
114#include <TVirtualMC.h>
115#include <TVirtualMCApplication.h>
5cf76849 116#include <TDatime.h>
252fff8d 117#include <TInterpreter.h>
85a5290f 118
3e2e3ece 119#include "AliAlignObj.h"
e8d02863 120#include "AliCDBEntry.h"
121#include "AliCDBManager.h"
732ee20f 122#include "AliGRPManager.h"
3e2e3ece 123#include "AliCDBStorage.h"
124#include "AliCTPRawData.h"
125#include "AliCentralTrigger.h"
e8d02863 126#include "AliCentralTrigger.h"
3e2e3ece 127#include "AliCodeTimer.h"
362c9d61 128#include "AliDAQ.h"
af7ba10c 129#include "AliDigitizer.h"
6d985680 130#include "AliESDEvent.h"
3e2e3ece 131#include "AliGRPObject.h"
132#include "AliGenEventHeader.h"
af7ba10c 133#include "AliGenerator.h"
3e2e3ece 134#include "AliGeomManager.h"
135#include "AliHLTSimulation.h"
136#include "AliHeader.h"
f7a1cc68 137#include "AliLego.h"
138#include "AliLegoGenerator.h"
e8d02863 139#include "AliLog.h"
3e2e3ece 140#include "AliMC.h"
141#include "AliMagF.h"
af7ba10c 142#include "AliModule.h"
3e2e3ece 143#include "AliPDG.h"
144#include "AliRawReaderDate.h"
145#include "AliRawReaderFile.h"
146#include "AliRawReaderRoot.h"
af7ba10c 147#include "AliRun.h"
f21fc003 148#include "AliDigitizationInput.h"
af7ba10c 149#include "AliRunLoader.h"
35ec1f70 150#include "AliStack.h"
af7ba10c 151#include "AliSimulation.h"
27fc67fa 152#include "AliSysInfo.h"
3e2e3ece 153#include "AliVertexGenFile.h"
85a5290f 154
66b0310c 155using std::ofstream;
85a5290f 156ClassImp(AliSimulation)
157
b856a511 158AliSimulation *AliSimulation::fgInstance = 0;
c1c44db3 159 const char* AliSimulation::fgkDetectorName[AliSimulation::fgkNDetectors] = {"ITS", "TPC", "TRD",
160 "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE","AD",
161 "FIT","MFT","HLT"};
85a5290f 162
163//_____________________________________________________________________________
795e4a22 164AliSimulation::AliSimulation(const char* configFileName,
95601147 165 const char* name, const char* title) :
166 TNamed(name, title),
167
35ec1f70 168 fRunGeneratorOnly(kFALSE),
95601147 169 fRunGeneration(kTRUE),
170 fRunSimulation(kTRUE),
024cf675 171 fLoadAlignFromCDB(kTRUE),
25be1e5c 172 fLoadAlObjsListOfDets("ALL"),
95601147 173 fMakeSDigits("ALL"),
174 fMakeDigits("ALL"),
28da60d3 175 fTriggerConfig(""),
95601147 176 fMakeDigitsFromHits(""),
0421c3d1 177 fWriteRawData(""),
06c7e392 178 fRawDataFileName(""),
179 fDeleteIntermediateFiles(kFALSE),
67327b72 180 fWriteSelRawData(kFALSE),
95601147 181 fStopOnError(kFALSE),
a5fe2c41 182 fUseMonitoring(kFALSE),
95601147 183 fNEvents(1),
184 fConfigFileName(configFileName),
185 fGAliceFileName("galice.root"),
18b43626 186 fEventsPerFile(),
95601147 187 fBkgrdFileNames(NULL),
995ad051 188 fAlignObjArray(NULL),
04bae0a0 189 fUseBkgrdVertex(kTRUE),
024cf675 190 fRegionOfInterest(kFALSE),
795e4a22 191 fCDBUri(""),
f1c1204d 192 fQARefUri(""),
ca30848f 193 fSpecCDBUri(),
795e4a22 194 fRun(-1),
195 fSeed(0),
196 fInitCDBCalled(kFALSE),
197 fInitRunNumberCalled(kFALSE),
198 fSetRunNumberFromDataCalled(kFALSE),
cae21299 199 fEmbeddingFlag(kFALSE),
3e2e3ece 200 fLego(NULL),
732ee20f 201 fKey(0),
202 fUseVertexFromCDB(0),
203 fUseMagFieldFromGRP(0),
204 fGRPWriteLocation(Form("local://%s", gSystem->pwd())),
475baf89 205 fUseTimeStampFromCDB(0),
206 fTimeStart(0),
207 fTimeEnd(0),
e3b20d9a 208 fQADetectors("ALL"),
209 fQATasks("ALL"),
759c1df1 210 fRunQA(kTRUE),
57acd2d2 211 fEventSpecie(AliRecoParam::kDefault),
75373542 212 fWriteQAExpertData(kTRUE),
1b1f5ae6 213 fGeometryFile(),
fc7e1b1c 214 fRunHLT("default"),
c4affb19 215 fpHLT(NULL),
fc7e1b1c 216 fWriteGRPEntry(kTRUE)
85a5290f 217{
218// create simulation object with default parameters
b856a511 219 fgInstance = this;
0421c3d1 220 SetGAliceFile("galice.root");
5b188f2f 221
222// for QA
634696f5 223 AliQAManager * qam = AliQAManager::QAManager(AliQAv1::kSIMMODE) ;
eca4fa66 224 qam->SetActiveDetectors(fQADetectors) ;
4e25ac79 225 fQATasks = Form("%d %d %d", AliQAv1::kHITS, AliQAv1::kSDIGITS, AliQAv1::kDIGITS) ;
eca4fa66 226 qam->SetTasks(fQATasks) ;
85a5290f 227}
228
229//_____________________________________________________________________________
85a5290f 230AliSimulation::~AliSimulation()
231{
232// clean up
233
18b43626 234 fEventsPerFile.Delete();
024cf675 235// if(fAlignObjArray) fAlignObjArray->Delete(); // fAlignObjArray->RemoveAll() ???
236// delete fAlignObjArray; fAlignObjArray=0;
18b43626 237
95601147 238 if (fBkgrdFileNames) {
239 fBkgrdFileNames->Delete();
240 delete fBkgrdFileNames;
241 }
ec92bee0 242
243 fSpecCDBUri.Delete();
b856a511 244 if (fgInstance==this) fgInstance = 0;
87932dab 245
bf76b847 246 AliQAManager::QAManager()->ShowQA() ;
247 AliQAManager::Destroy() ;
87932dab 248 AliCodeTimer::Instance()->Print();
85a5290f 249}
250
251
252//_____________________________________________________________________________
253void AliSimulation::SetNumberOfEvents(Int_t nEvents)
254{
255// set the number of events for one run
256
257 fNEvents = nEvents;
258}
259
260//_____________________________________________________________________________
f1c1204d 261void AliSimulation::InitQA()
262{
263 // activate a default CDB storage
264 // First check if we have any CDB storage set, because it is used
265 // to retrieve the calibration and alignment constants
266
267 if (fInitCDBCalled) return;
268 fInitCDBCalled = kTRUE;
269
634696f5 270 AliQAManager * qam = AliQAManager::QAManager(AliQAv1::kSIMMODE) ;
eca4fa66 271 qam->SetActiveDetectors(fQADetectors) ;
4e25ac79 272 fQATasks = Form("%d %d %d", AliQAv1::kHITS, AliQAv1::kSDIGITS, AliQAv1::kDIGITS) ;
eca4fa66 273 qam->SetTasks(fQATasks) ;
75373542 274 if (fWriteQAExpertData)
eca4fa66 275 qam->SetWriteExpert() ;
f1c1204d 276
eca4fa66 277 if (qam->IsDefaultStorageSet()) {
f1c1204d 278 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
279 AliWarning("Default QA reference storage has been already set !");
280 AliWarning(Form("Ignoring the default storage declared in AliSimulation: %s",fQARefUri.Data()));
281 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
eca4fa66 282 fQARefUri = qam->GetDefaultStorage()->GetURI();
f1c1204d 283 } else {
284 if (fQARefUri.Length() > 0) {
285 AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
286 AliDebug(2, Form("Default QA reference storage is set to: %s", fQARefUri.Data()));
287 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
288 } else {
289 fQARefUri="local://$ALICE_ROOT/QARef";
290 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
291 AliWarning("Default QA reference storage not yet set !!!!");
292 AliWarning(Form("Setting it now to: %s", fQARefUri.Data()));
293 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
294 }
eca4fa66 295 qam->SetDefaultStorage(fQARefUri);
f1c1204d 296 }
297}
298
299//_____________________________________________________________________________
795e4a22 300void AliSimulation::InitCDB()
024cf675 301{
302// activate a default CDB storage
303// First check if we have any CDB storage set, because it is used
304// to retrieve the calibration and alignment constants
305
795e4a22 306 if (fInitCDBCalled) return;
307 fInitCDBCalled = kTRUE;
308
024cf675 309 AliCDBManager* man = AliCDBManager::Instance();
ec92bee0 310 if (man->IsDefaultStorageSet())
024cf675 311 {
ec92bee0 312 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
313 AliWarning("Default CDB storage has been already set !");
ced249e6 314 AliWarning(Form("Ignoring the default storage declared in AliSimulation: %s",fCDBUri.Data()));
ec92bee0 315 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
795e4a22 316 fCDBUri = man->GetDefaultStorage()->GetURI();
ec92bee0 317 }
318 else {
795e4a22 319 if (fCDBUri.Length() > 0)
320 {
321 AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
322 AliDebug(2, Form("Default CDB storage is set to: %s", fCDBUri.Data()));
323 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
324 } else {
162637e4 325 fCDBUri="local://$ALICE_ROOT/OCDB";
795e4a22 326 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
327 AliWarning("Default CDB storage not yet set !!!!");
328 AliWarning(Form("Setting it now to: %s", fCDBUri.Data()));
329 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
330
331 }
ec92bee0 332 man->SetDefaultStorage(fCDBUri);
333 }
334
335 // Now activate the detector specific CDB storage locations
336 for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
337 TObject* obj = fSpecCDBUri[i];
338 if (!obj) continue;
b8ec52f6 339 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
340 AliDebug(2, Form("Specific CDB storage for %s is set to: %s",obj->GetName(),obj->GetTitle()));
341 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
c3a7b59a 342 man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
ec92bee0 343 }
795e4a22 344
024cf675 345}
346
347//_____________________________________________________________________________
795e4a22 348void AliSimulation::InitRunNumber(){
349// check run number. If not set, set it to 0 !!!!
350
351 if (fInitRunNumberCalled) return;
352 fInitRunNumberCalled = kTRUE;
353
354 AliCDBManager* man = AliCDBManager::Instance();
355 if (man->GetRun() >= 0)
356 {
8c8fbdcd 357 AliFatal(Form("Run number cannot be set in AliCDBManager before start of simulation: "
358 "Use external variable DC_RUN or AliSimulation::SetRun()!"));
795e4a22 359 }
8c8fbdcd 360
361 if(fRun >= 0) {
795e4a22 362 AliDebug(2, Form("Setting CDB run number to: %d",fRun));
8c8fbdcd 363 } else {
795e4a22 364 fRun=0;
76c8e8d6 365 AliWarning(Form("Run number not yet set !!!! Setting it now to: %d",
366 fRun));
795e4a22 367 }
8c8fbdcd 368 man->SetRun(fRun);
024cf675 369
795e4a22 370 man->Print();
024cf675 371
372}
373
374//_____________________________________________________________________________
795e4a22 375void AliSimulation::SetCDBLock() {
376 // Set CDB lock: from now on it is forbidden to reset the run number
377 // or the default storage or to activate any further storage!
378
6fc2efbf 379 ULong64_t key = AliCDBManager::Instance()->SetLock(1);
732ee20f 380 if (key) fKey = key;
795e4a22 381}
382
383//_____________________________________________________________________________
384void AliSimulation::SetDefaultStorage(const char* uri) {
f1c1204d 385 // Store the desired default CDB storage location
386 // Activate it later within the Run() method
387
795e4a22 388 fCDBUri = uri;
f1c1204d 389
390}
00aa02d5 391
f1c1204d 392//_____________________________________________________________________________
393void AliSimulation::SetQARefDefaultStorage(const char* uri) {
394 // Store the desired default CDB storage location
395 // Activate it later within the Run() method
396
397 fQARefUri = uri;
4e25ac79 398 AliQAv1::SetQARefStorage(fQARefUri.Data()) ;
00aa02d5 399}
400
401//_____________________________________________________________________________
c3a7b59a 402void AliSimulation::SetSpecificStorage(const char* calibType, const char* uri) {
ec92bee0 403// Store a detector-specific CDB storage location
404// Activate it later within the Run() method
024cf675 405
c3a7b59a 406 AliCDBPath aPath(calibType);
407 if(!aPath.IsValid()){
408 AliError(Form("Not a valid path: %s", calibType));
409 return;
410 }
411
412 TObject* obj = fSpecCDBUri.FindObject(calibType);
ec92bee0 413 if (obj) fSpecCDBUri.Remove(obj);
c3a7b59a 414 fSpecCDBUri.Add(new TNamed(calibType, uri));
024cf675 415
416}
417
418//_____________________________________________________________________________
795e4a22 419void AliSimulation::SetRunNumber(Int_t run)
420{
421// sets run number
422// Activate it later within the Run() method
423
424 fRun = run;
425}
426
427//_____________________________________________________________________________
428void AliSimulation::SetSeed(Int_t seed)
429{
430// sets seed number
431// Activate it later within the Run() method
432
433 fSeed = seed;
434}
435
436//_____________________________________________________________________________
437Bool_t AliSimulation::SetRunNumberFromData()
438{
439 // Set the CDB manager run number
440 // The run number is retrieved from gAlice
441
442 if (fSetRunNumberFromDataCalled) return kTRUE;
443 fSetRunNumberFromDataCalled = kTRUE;
444
445 AliCDBManager* man = AliCDBManager::Instance();
446 Int_t runData = -1, runCDB = -1;
447
448 AliRunLoader* runLoader = LoadRun("READ");
449 if (!runLoader) return kFALSE;
450 else {
d3b3a3b2 451 runData = runLoader->GetHeader()->GetRun();
795e4a22 452 delete runLoader;
453 }
454
455 runCDB = man->GetRun();
456 if(runCDB >= 0) {
457 if (runCDB != runData) {
458 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
459 AliWarning(Form("A run number was previously set in AliCDBManager: %d !", runCDB));
460 AliWarning(Form("It will be replaced with the run number got from run header: %d !", runData));
461 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
462 }
463
464 }
465
466 man->SetRun(runData);
467 fRun = runData;
468
469 if(man->GetRun() < 0) {
470 AliError("Run number not properly initalized!");
471 return kFALSE;
472 }
473
474 man->Print();
475
476 return kTRUE;
477}
478
479//_____________________________________________________________________________
85a5290f 480void AliSimulation::SetConfigFile(const char* fileName)
481{
482// set the name of the config file
483
484 fConfigFileName = fileName;
485}
486
487//_____________________________________________________________________________
0421c3d1 488void AliSimulation::SetGAliceFile(const char* fileName)
489{
490// set the name of the galice file
491// the path is converted to an absolute one if it is relative
492
493 fGAliceFileName = fileName;
494 if (!gSystem->IsAbsoluteFileName(fGAliceFileName)) {
495 char* absFileName = gSystem->ConcatFileName(gSystem->WorkingDirectory(),
496 fGAliceFileName);
497 fGAliceFileName = absFileName;
498 delete[] absFileName;
499 }
ac1671c0 500
501 AliDebug(2, Form("galice file name set to %s", fileName));
0421c3d1 502}
503
504//_____________________________________________________________________________
18b43626 505void AliSimulation::SetEventsPerFile(const char* detector, const char* type,
506 Int_t nEvents)
507{
508// set the number of events per file for the given detector and data type
509// ("Hits", "Summable Digits", "Digits", "Reconstructed Points" or "Tracks")
510
511 TNamed* obj = new TNamed(detector, type);
512 obj->SetUniqueID(nEvents);
513 fEventsPerFile.Add(obj);
514}
515
516//_____________________________________________________________________________
6bae477a 517Bool_t AliSimulation::MisalignGeometry(AliRunLoader *runLoader)
518{
519 // Read the alignment objects from CDB.
520 // Each detector is supposed to have the
521 // alignment objects in DET/Align/Data CDB path.
522 // All the detector objects are then collected,
523 // sorted by geometry level (starting from ALIC) and
524 // then applied to the TGeo geometry.
525 // Finally an overlaps check is performed.
526
74ae4297 527 if (!AliGeomManager::GetGeometry() || !AliGeomManager::GetGeometry()->IsClosed()) {
528 AliError("Can't apply the misalignment! Geometry is not loaded or it is still opened!");
0717eed2 529 return kFALSE;
530 }
795e4a22 531
532 // initialize CDB storage, run number, set CDB lock
533 InitCDB();
534// if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
535 SetCDBLock();
536
6bae477a 537 Bool_t delRunLoader = kFALSE;
538 if (!runLoader) {
539 runLoader = LoadRun("READ");
540 if (!runLoader) return kFALSE;
541 delRunLoader = kTRUE;
542 }
795e4a22 543
b856a511 544 // Export ideal geometry
d97f1dbe 545 if(!IsGeometryFromFile()) AliGeomManager::GetGeometry()->Export("geometry.root");
b856a511 546
25be1e5c 547 // Load alignment data from CDB and apply to geometry through AliGeomManager
6bae477a 548 if(fLoadAlignFromCDB){
25be1e5c 549
550 TString detStr = fLoadAlObjsListOfDets;
551 TString loadAlObjsListOfDets = "";
552
553 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
554 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
555 AliModule* det = (AliModule*) detArray->At(iDet);
556 if (!det || !det->IsActive()) continue;
557 if (IsSelected(det->GetName(), detStr)) {
0717eed2 558 //add det to list of dets to be aligned from CDB
559 loadAlObjsListOfDets += det->GetName();
560 loadAlObjsListOfDets += " ";
25be1e5c 561 }
562 } // end loop over detectors
53dd3c3d 563 loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
45daac75 564 AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
25be1e5c 565 }else{
566 // Check if the array with alignment objects was
567 // provided by the user. If yes, apply the objects
568 // to the present TGeo geometry
569 if (fAlignObjArray) {
45daac75 570 if (AliGeomManager::ApplyAlignObjsToGeom(*fAlignObjArray) == kFALSE) {
0717eed2 571 AliError("The misalignment of one or more volumes failed!"
572 "Compare the list of simulated detectors and the list of detector alignment data!");
573 if (delRunLoader) delete runLoader;
574 return kFALSE;
6bae477a 575 }
576 }
6bae477a 577 }
578
ef7ff1f9 579 // Update the internal geometry of modules (ITS needs it)
25be1e5c 580 TString detStr = fLoadAlObjsListOfDets;
ef7ff1f9 581 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
582 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
583
584 AliModule* det = (AliModule*) detArray->At(iDet);
585 if (!det || !det->IsActive()) continue;
586 if (IsSelected(det->GetName(), detStr)) {
587 det->UpdateInternalGeometry();
588 }
589 } // end loop over detectors
590
591
6bae477a 592 if (delRunLoader) delete runLoader;
593
594 return kTRUE;
595}
596
6bae477a 597//_____________________________________________________________________________
85a5290f 598void AliSimulation::MergeWith(const char* fileName, Int_t nSignalPerBkgrd)
599{
600// add a file with background events for merging
601
602 TObjString* fileNameStr = new TObjString(fileName);
603 fileNameStr->SetUniqueID(nSignalPerBkgrd);
95601147 604 if (!fBkgrdFileNames) fBkgrdFileNames = new TObjArray;
85a5290f 605 fBkgrdFileNames->Add(fileNameStr);
606}
607
ca30848f 608void AliSimulation::EmbedInto(const char* fileName, Int_t nSignalPerBkgrd)
609{
610// add a file with background events for embeddin
611 MergeWith(fileName, nSignalPerBkgrd);
612 fEmbeddingFlag = kTRUE;
613}
85a5290f 614
615//_____________________________________________________________________________
616Bool_t AliSimulation::Run(Int_t nEvents)
617{
618// run the generation, simulation and digitization
619
c65c502a 620
99c136e1 621 AliCodeTimerAuto("",0)
6fcf567c 622 AliSysInfo::AddStamp("Start_Run");
87932dab 623
795e4a22 624 // Load run number and seed from environmental vars
625 ProcessEnvironmentVars();
6fcf567c 626 AliSysInfo::AddStamp("ProcessEnvironmentVars");
b0314964 627
795e4a22 628 gRandom->SetSeed(fSeed);
629
85a5290f 630 if (nEvents > 0) fNEvents = nEvents;
631
35ec1f70 632 // Run generator-only code on demand
633 if (fRunGeneratorOnly)
634 {
635 if(!RunGeneratorOnly())
636 {
637 if (fStopOnError) return kFALSE;
638 }
639 else
640 return kTRUE;
641 }
642
c4affb19 643 // create and setup the HLT instance
644 if (!fRunHLT.IsNull() && !CreateHLT()) {
645 if (fStopOnError) return kFALSE;
646 // disable HLT
647 fRunHLT="";
648 }
c516e34c 649
85a5290f 650 // generation and simulation -> hits
651 if (fRunGeneration) {
85a5290f 652 if (!RunSimulation()) if (fStopOnError) return kFALSE;
653 }
6fcf567c 654 AliSysInfo::AddStamp("RunSimulation");
795e4a22 655
656 // initialize CDB storage from external environment
657 // (either CDB manager or AliSimulation setters),
658 // if not already done in RunSimulation()
659 InitCDB();
6fcf567c 660 AliSysInfo::AddStamp("InitCDB");
795e4a22 661
662 // Set run number in CDBManager from data
663 // From this point on the run number must be always loaded from data!
664 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
665
666 // Set CDB lock: from now on it is forbidden to reset the run number
667 // or the default storage or to activate any further storage!
668 SetCDBLock();
6bae477a 669
25be1e5c 670 // If RunSimulation was not called, load the geometry and misalign it
74ae4297 671 if (!AliGeomManager::GetGeometry()) {
672 // Initialize the geometry manager
1b1f5ae6 673 AliGeomManager::LoadGeometry("geometry.root");
2eab8cf7 674 AliSysInfo::AddStamp("GetGeometry");
ff5970a3 675// // Check that the consistency of symbolic names for the activated subdetectors
676// // in the geometry loaded by AliGeomManager
677// AliRunLoader* runLoader = LoadRun("READ");
678// if (!runLoader) return kFALSE;
679//
680// TString detsToBeChecked = "";
681// TObjArray* detArray = runLoader->GetAliRun()->Detectors();
682// for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
683// AliModule* det = (AliModule*) detArray->At(iDet);
684// if (!det || !det->IsActive()) continue;
685// detsToBeChecked += det->GetName();
686// detsToBeChecked += " ";
687// } // end loop over detectors
688// if(!AliGeomManager::CheckSymNamesLUT(detsToBeChecked.Data()))
689 if(!AliGeomManager::CheckSymNamesLUT("ALL"))
0bf7aade 690 AliFatalClass("Current loaded geometry differs in the definition of symbolic names!");
ff5970a3 691
74ae4297 692 if (!AliGeomManager::GetGeometry()) if (fStopOnError) return kFALSE;
693 // Misalign geometry
25be1e5c 694 if(!MisalignGeometry()) if (fStopOnError) return kFALSE;
6bae477a 695 }
6fcf567c 696 AliSysInfo::AddStamp("MissalignGeometry");
25be1e5c 697
27fc67fa 698
85a5290f 699 // hits -> summable digits
27fc67fa 700 AliSysInfo::AddStamp("Start_sdigitization");
85a5290f 701 if (!fMakeSDigits.IsNull()) {
702 if (!RunSDigitization(fMakeSDigits)) if (fStopOnError) return kFALSE;
a1b90a73 703
85a5290f 704 }
27fc67fa 705 AliSysInfo::AddStamp("Stop_sdigitization");
c65c502a 706
27fc67fa 707 AliSysInfo::AddStamp("Start_digitization");
795e4a22 708 // summable digits -> digits
85a5290f 709 if (!fMakeDigits.IsNull()) {
710 if (!RunDigitization(fMakeDigits, fMakeDigitsFromHits)) {
711 if (fStopOnError) return kFALSE;
712 }
a1b90a73 713 }
27fc67fa 714 AliSysInfo::AddStamp("Stop_digitization");
85a5290f 715
795e4a22 716
717
85a5290f 718 // hits -> digits
719 if (!fMakeDigitsFromHits.IsNull()) {
95601147 720 if (fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
ac1671c0 721 AliWarning(Form("Merging and direct creation of digits from hits "
722 "was selected for some detectors. "
723 "No merging will be done for the following detectors: %s",
724 fMakeDigitsFromHits.Data()));
85a5290f 725 }
726 if (!RunHitsDigitization(fMakeDigitsFromHits)) {
727 if (fStopOnError) return kFALSE;
728 }
729 }
730
6fcf567c 731 AliSysInfo::AddStamp("Hits2Digits");
795e4a22 732
733
a5a091ce 734 // digits -> trigger
4471cf15 735 if (!fTriggerConfig.IsNull() && !RunTrigger(fTriggerConfig,fMakeDigits)) {
087426de 736 if (fStopOnError) return kFALSE;
a5a091ce 737 }
738
6fcf567c 739 AliSysInfo::AddStamp("RunTrigger");
795e4a22 740
741
0421c3d1 742 // digits -> raw data
743 if (!fWriteRawData.IsNull()) {
06c7e392 744 if (!WriteRawData(fWriteRawData, fRawDataFileName,
67327b72 745 fDeleteIntermediateFiles,fWriteSelRawData)) {
0421c3d1 746 if (fStopOnError) return kFALSE;
747 }
748 }
749
6fcf567c 750 AliSysInfo::AddStamp("WriteRaw");
795e4a22 751
5f6d0c0d 752 // run HLT simulation on simulated digit data if raw data is not
753 // simulated, otherwise its called as part of WriteRawData
754 if (!fRunHLT.IsNull() && fWriteRawData.IsNull()) {
cae21299 755 if (!RunHLT()) {
756 if (fStopOnError) return kFALSE;
757 }
758 }
6fcf567c 759
760 AliSysInfo::AddStamp("RunHLT");
795e4a22 761
04236e67 762 //QA
f5cb4aec 763 if (fRunQA) {
764 Bool_t rv = RunQA() ;
765 if (!rv)
766 if (fStopOnError)
767 return kFALSE ;
768 }
795e4a22 769
6fcf567c 770 AliSysInfo::AddStamp("RunQA");
771
989744a6 772 TString snapshotFileOut("");
f5cb4aec 773 if(TString(gSystem->Getenv("OCDB_SNAPSHOT_CREATE")) == TString("kTRUE")){
774 AliInfo(" ******** Creating the snapshot! *********");
775 TString snapshotFile(gSystem->Getenv("OCDB_SNAPSHOT_FILENAME"));
776 if(!(snapshotFile.IsNull() || snapshotFile.IsWhitespace()))
777 snapshotFileOut = snapshotFile;
778 else
779 snapshotFileOut="OCDB.root";
c022b397 780 AliCDBManager::Instance()->DumpToSnapshotFile(snapshotFileOut.Data(),kFALSE);
f5cb4aec 781 }
782
795e4a22 783 // Cleanup of CDB manager: cache and active storages!
784 AliCDBManager::Instance()->ClearCache();
785
85a5290f 786 return kTRUE;
787}
788
3e2e3ece 789//_______________________________________________________________________
790Bool_t AliSimulation::RunLego(const char *setup, Int_t nc1, Float_t c1min,
791 Float_t c1max,Int_t nc2,Float_t c2min,Float_t c2max,
792 Float_t rmin,Float_t rmax,Float_t zmax, AliLegoGenerator* gener, Int_t nev)
793{
794 //
795 // Generates lego plots of:
796 // - radiation length map phi vs theta
797 // - radiation length map phi vs eta
798 // - interaction length map
799 // - g/cm2 length map
800 //
801 // ntheta bins in theta, eta
802 // themin minimum angle in theta (degrees)
803 // themax maximum angle in theta (degrees)
804 // nphi bins in phi
805 // phimin minimum angle in phi (degrees)
806 // phimax maximum angle in phi (degrees)
807 // rmin minimum radius
808 // rmax maximum radius
809 //
810 //
811 // The number of events generated = ntheta*nphi
812 // run input parameters in macro setup (default="Config.C")
813 //
814 // Use macro "lego.C" to visualize the 3 lego plots in spherical coordinates
815 //Begin_Html
816 /*
817 <img src="picts/AliRunLego1.gif">
818 */
819 //End_Html
820 //Begin_Html
821 /*
822 <img src="picts/AliRunLego2.gif">
823 */
824 //End_Html
825 //Begin_Html
826 /*
827 <img src="picts/AliRunLego3.gif">
828 */
829 //End_Html
830 //
831
832// run the generation and simulation
833
99c136e1 834 AliCodeTimerAuto("",0)
3e2e3ece 835
836 // initialize CDB storage and run number from external environment
837 // (either CDB manager or AliSimulation setters)
838 InitCDB();
839 InitRunNumber();
840 SetCDBLock();
841
842 if (!gAlice) {
843 AliError("no gAlice object. Restart aliroot and try again.");
844 return kFALSE;
845 }
846 if (gAlice->Modules()->GetEntries() > 0) {
847 AliError("gAlice was already run. Restart aliroot and try again.");
848 return kFALSE;
849 }
850
851 AliInfo(Form("initializing gAlice with config file %s",
852 fConfigFileName.Data()));
853
854 // Number of events
855 if (nev == -1) nev = nc1 * nc2;
856
857 // check if initialisation has been done
858 // If runloader has been initialized, set the number of events per file to nc1 * nc2
859
860 // Set new generator
861 if (!gener) gener = new AliLegoGenerator();
862 //
863 // Configure Generator
864
865 gener->SetRadiusRange(rmin, rmax);
866 gener->SetZMax(zmax);
867 gener->SetCoor1Range(nc1, c1min, c1max);
868 gener->SetCoor2Range(nc2, c2min, c2max);
869
870
871 //Create Lego object
872 fLego = new AliLego("lego",gener);
873
874 //__________________________________________________________________________
875
876 gAlice->Announce();
877
878 gROOT->LoadMacro(setup);
879 gInterpreter->ProcessLine(gAlice->GetConfigFunction());
880
881 if(AliCDBManager::Instance()->GetRun() >= 0) {
882 SetRunNumber(AliCDBManager::Instance()->GetRun());
883 } else {
884 AliWarning("Run number not initialized!!");
885 }
f7a1cc68 886
33c3c91a 887 AliRunLoader::Instance()->CdGAFile();
3e2e3ece 888
889 AliPDG::AddParticlesToPdgDataBase();
890
f7a1cc68 891 gMC->SetMagField(TGeoGlobalMagField::Instance()->GetField());
892
55338a9a 893 gAlice->GetMCApp()->Init();
894
f7a1cc68 895
3e2e3ece 896 //Must be here because some MCs (G4) adds detectors here and not in Config.C
897 gAlice->InitLoaders();
33c3c91a 898 AliRunLoader::Instance()->MakeTree("E");
3e2e3ece 899
900 //
901 // Save stuff at the beginning of the file to avoid file corruption
33c3c91a 902 AliRunLoader::Instance()->CdGAFile();
3e2e3ece 903 gAlice->Write();
904
905 //Save current generator
906 AliGenerator *gen=gAlice->GetMCApp()->Generator();
907 gAlice->GetMCApp()->ResetGenerator(gener);
908 //Prepare MC for Lego Run
909 gMC->InitLego();
910
911 //Run Lego Object
912
913
33c3c91a 914 AliRunLoader::Instance()->SetNumberOfEventsPerFile(nev);
3e2e3ece 915 gMC->ProcessRun(nev);
916
917 // End of this run, close files
918 FinishRun();
919 // Restore current generator
920 gAlice->GetMCApp()->ResetGenerator(gen);
921 // Delete Lego Object
922 delete fLego;
923
924 return kTRUE;
925}
926
85a5290f 927//_____________________________________________________________________________
8480396b 928Bool_t AliSimulation::RunTrigger(const char* config, const char* detectors)
a5a091ce 929{
930 // run the trigger
931
99c136e1 932 AliCodeTimerAuto("",0)
a5a091ce 933
795e4a22 934 // initialize CDB storage from external environment
935 // (either CDB manager or AliSimulation setters),
936 // if not already done in RunSimulation()
937 InitCDB();
938
939 // Set run number in CDBManager from data
940 // From this point on the run number must be always loaded from data!
941 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
942
943 // Set CDB lock: from now on it is forbidden to reset the run number
944 // or the default storage or to activate any further storage!
945 SetCDBLock();
946
bacbe0fd 947 AliRunLoader* runLoader = LoadRun("READ");
948 if (!runLoader) return kFALSE;
51f6d619 949 TString trconfiguration = config;
bacbe0fd 950
51f6d619 951 if (trconfiguration.IsNull()) {
28da60d3 952 if(!fTriggerConfig.IsNull()) {
953 trconfiguration = fTriggerConfig;
087426de 954 }
51f6d619 955 else
8480396b 956 AliWarning("No trigger descriptor is specified. Loading the one that is in the CDB.");
087426de 957 }
958
0f46f5fa 959 runLoader->MakeTree( "GG" );
bacbe0fd 960 AliCentralTrigger* aCTP = runLoader->GetTrigger();
51f6d619 961 // Load Configuration
962 if (!aCTP->LoadConfiguration( trconfiguration ))
963 return kFALSE;
a5a091ce 964
51f6d619 965 // digits -> trigger
8480396b 966 if( !aCTP->RunTrigger( runLoader , detectors ) ) {
a5a091ce 967 if (fStopOnError) {
51f6d619 968 // delete aCTP;
969 return kFALSE;
a5a091ce 970 }
bacbe0fd 971 }
a5a091ce 972
bacbe0fd 973 delete runLoader;
a5a091ce 974
bacbe0fd 975 return kTRUE;
a5a091ce 976}
977
007155cc 978//_____________________________________________________________________________
979Bool_t AliSimulation::WriteTriggerRawData()
980{
981 // Writes the CTP (trigger) DDL raw data
982 // Details of the format are given in the
983 // trigger TDR - pages 134 and 135.
984 AliCTPRawData writer;
a1f9c4b8 985 //writer.RawData();
986 writer.RawDataRun2();
a5a091ce 987
007155cc 988 return kTRUE;
989}
a5a091ce 990
991//_____________________________________________________________________________
95601147 992Bool_t AliSimulation::RunSimulation(Int_t nEvents)
85a5290f 993{
994// run the generation and simulation
995
99c136e1 996 AliCodeTimerAuto("",0)
4df28b43 997
795e4a22 998 // initialize CDB storage and run number from external environment
999 // (either CDB manager or AliSimulation setters)
6fcf567c 1000 AliSysInfo::AddStamp("RunSimulation_Begin");
795e4a22 1001 InitCDB();
6fcf567c 1002 AliSysInfo::AddStamp("RunSimulation_InitCDB");
795e4a22 1003 InitRunNumber();
f5cb4aec 1004
795e4a22 1005 SetCDBLock();
6fcf567c 1006 AliSysInfo::AddStamp("RunSimulation_SetCDBLock");
795e4a22 1007
95601147 1008 if (!gAlice) {
ac1671c0 1009 AliError("no gAlice object. Restart aliroot and try again.");
95601147 1010 return kFALSE;
1011 }
1012 if (gAlice->Modules()->GetEntries() > 0) {
ac1671c0 1013 AliError("gAlice was already run. Restart aliroot and try again.");
95601147 1014 return kFALSE;
1015 }
a5fe2c41 1016
1017 // Setup monitoring if requested
1018 gAlice->GetMCApp()->SetUseMonitoring(fUseMonitoring);
95601147 1019
ac1671c0 1020 AliInfo(Form("initializing gAlice with config file %s",
1021 fConfigFileName.Data()));
3e2e3ece 1022
1023 //
1024 // Initialize ALICE Simulation run
1025 //
3e2e3ece 1026 gAlice->Announce();
1027
732ee20f 1028 //
1029 // If requested set the mag. field from the GRP entry.
1030 // After this the field is loccked and cannot be changed by Config.C
1031 if (fUseMagFieldFromGRP) {
1032 AliGRPManager grpM;
1033 grpM.ReadGRPEntry();
1034 grpM.SetMagField();
1035 AliInfo("Field is locked now. It cannot be changed in Config.C");
1036 }
1037//
1038// Execute Config.C
252fff8d 1039 TInterpreter::EErrorCode interpreterError=TInterpreter::kNoError;
3e2e3ece 1040 gROOT->LoadMacro(fConfigFileName.Data());
252fff8d 1041 Long_t interpreterResult=gInterpreter->ProcessLine(gAlice->GetConfigFunction(), &interpreterError);
1042 if (interpreterResult!=0 || interpreterError!=TInterpreter::kNoError) {
1043 AliFatal(Form("execution of config file \"%s\" failed with error %d", fConfigFileName.Data(), (int)interpreterError));
1044 }
6fcf567c 1045 AliSysInfo::AddStamp("RunSimulation_Config");
3e2e3ece 1046
732ee20f 1047//
1048// If requested obtain the vertex position and vertex sigma_z from the CDB
1049// This overwrites the settings from the Config.C
1050 if (fUseVertexFromCDB) {
1051 Double_t vtxPos[3] = {0., 0., 0.};
1052 Double_t vtxSig[3] = {0., 0., 0.};
b71fc657 1053 AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
58c338d2 1054 if (entry) {
1055 AliESDVertex* vertex = dynamic_cast<AliESDVertex*> (entry->GetObject());
1056 if (vertex) {
1057 if(vertex->GetXRes()>2.8) { // > pipe radius --> it's a dummy object, don't use it
1058 entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexSPD");
c134270c 1059 if (entry) vertex = dynamic_cast<AliESDVertex*> (entry->GetObject());
58c338d2 1060 }
1061 }
1062 if (vertex) {
1063 vertex->GetXYZ(vtxPos);
1064 vertex->GetSigmaXYZ(vtxSig);
1065 AliInfo("Overwriting Config.C vertex settings !");
1066 AliInfo(Form("Vertex position from OCDB entry: x = %13.3f, y = %13.3f, z = %13.3f (sigma = %13.3f)\n",
1067 vtxPos[0], vtxPos[1], vtxPos[2], vtxSig[2]));
1068
1069 AliGenerator *gen = gAlice->GetMCApp()->Generator();
1070 gen->SetOrigin(vtxPos[0], vtxPos[1], vtxPos[2]); // vertex position
1071 gen->SetSigmaZ(vtxSig[2]);
766f0285 1072 }
732ee20f 1073 }
1074 }
475baf89 1075
1076 // If requested we take the SOR and EOR time-stamps from the GRP and use them
1077 // in order to generate the event time-stamps
1078 if (fUseTimeStampFromCDB) {
1079 AliGRPManager grpM;
1080 grpM.ReadGRPEntry();
1081 const AliGRPObject *grpObj = grpM.GetGRPData();
1082 if (!grpObj || (grpObj->GetTimeEnd() <= grpObj->GetTimeStart())) {
1083 AliError("Missing GRP or bad SOR/EOR time-stamps! Switching off the time-stamp generation from GRP!");
1084 fTimeStart = fTimeEnd = 0;
1085 fUseTimeStampFromCDB = kFALSE;
1086 }
1087 else {
1088 fTimeStart = grpObj->GetTimeStart();
1089 fTimeEnd = grpObj->GetTimeEnd();
1090 }
1091 }
732ee20f 1092
3e2e3ece 1093 if(AliCDBManager::Instance()->GetRun() >= 0) {
33c3c91a 1094 AliRunLoader::Instance()->SetRunNumber(AliCDBManager::Instance()->GetRun());
c516e34c 1095 AliRunLoader::Instance()->SetNumberOfEventsPerRun(fNEvents);
3e2e3ece 1096 } else {
1097 AliWarning("Run number not initialized!!");
1098 }
1099
33c3c91a 1100 AliRunLoader::Instance()->CdGAFile();
732ee20f 1101
1102
3e2e3ece 1103 AliPDG::AddParticlesToPdgDataBase();
1104
f7a1cc68 1105 gMC->SetMagField(TGeoGlobalMagField::Instance()->GetField());
6fcf567c 1106 AliSysInfo::AddStamp("RunSimulation_GetField");
55338a9a 1107 gAlice->GetMCApp()->Init();
1108 AliSysInfo::AddStamp("RunSimulation_InitMCApp");
1109
3e2e3ece 1110 //Must be here because some MCs (G4) adds detectors here and not in Config.C
1111 gAlice->InitLoaders();
33c3c91a 1112 AliRunLoader::Instance()->MakeTree("E");
1113 AliRunLoader::Instance()->LoadKinematics("RECREATE");
1114 AliRunLoader::Instance()->LoadTrackRefs("RECREATE");
1115 AliRunLoader::Instance()->LoadHits("all","RECREATE");
3e2e3ece 1116 //
1117 // Save stuff at the beginning of the file to avoid file corruption
33c3c91a 1118 AliRunLoader::Instance()->CdGAFile();
3e2e3ece 1119 gAlice->Write();
1120 gAlice->SetEventNrInRun(-1); //important - we start Begin event from increasing current number in run
6fcf567c 1121 AliSysInfo::AddStamp("RunSimulation_InitLoaders");
3e2e3ece 1122 //___________________________________________________________________________________________
795e4a22 1123
6fcf567c 1124 AliSysInfo::AddStamp("RunSimulation_TriggerDescriptor");
087426de 1125
6bae477a 1126 // Set run number in CDBManager
024cf675 1127 AliInfo(Form("Run number: %d",AliCDBManager::Instance()->GetRun()));
1128
33c3c91a 1129 AliRunLoader* runLoader = AliRunLoader::Instance();
024cf675 1130 if (!runLoader) {
1131 AliError(Form("gAlice has no run loader object. "
1132 "Check your config file: %s", fConfigFileName.Data()));
1133 return kFALSE;
1134 }
1135 SetGAliceFile(runLoader->GetFileName());
795e4a22 1136
6bae477a 1137 // Misalign geometry
caf9c464 1138#if ROOT_VERSION_CODE < 331527
74ae4297 1139 AliGeomManager::SetGeometry(gGeoManager);
ff5970a3 1140
1141 // Check that the consistency of symbolic names for the activated subdetectors
1142 // in the geometry loaded by AliGeomManager
1143 TString detsToBeChecked = "";
1144 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1145 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1146 AliModule* det = (AliModule*) detArray->At(iDet);
1147 if (!det || !det->IsActive()) continue;
1148 detsToBeChecked += det->GetName();
1149 detsToBeChecked += " ";
1150 } // end loop over detectors
1151 if(!AliGeomManager::CheckSymNamesLUT(detsToBeChecked.Data()))
0bf7aade 1152 AliFatalClass("Current loaded geometry differs in the definition of symbolic names!");
caf9c464 1153 MisalignGeometry(runLoader);
6fcf567c 1154 AliSysInfo::AddStamp("RunSimulation_MisalignGeometry");
caf9c464 1155#endif
995ad051 1156
33c3c91a 1157// AliRunLoader* runLoader = AliRunLoader::Instance();
024cf675 1158// if (!runLoader) {
1159// AliError(Form("gAlice has no run loader object. "
1160// "Check your config file: %s", fConfigFileName.Data()));
1161// return kFALSE;
1162// }
1163// SetGAliceFile(runLoader->GetFileName());
85a5290f 1164
3e2e3ece 1165 if (!gAlice->GetMCApp()->Generator()) {
ac1671c0 1166 AliError(Form("gAlice has no generator object. "
1167 "Check your config file: %s", fConfigFileName.Data()));
04bae0a0 1168 return kFALSE;
1169 }
fc7e1b1c 1170
1171 // Write GRP entry corresponding to the setting found in Cofig.C
1172 if (fWriteGRPEntry)
1173 WriteGRPEntry();
6fcf567c 1174 AliSysInfo::AddStamp("RunSimulation_WriteGRP");
fc7e1b1c 1175
05526d44 1176 if (nEvents <= 0) nEvents = fNEvents;
04bae0a0 1177
1178 // get vertex from background file in case of merging
1179 if (fUseBkgrdVertex &&
1180 fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
05526d44 1181 Int_t signalPerBkgrd = GetNSignalPerBkgrd(nEvents);
04bae0a0 1182 const char* fileName = ((TObjString*)
1183 (fBkgrdFileNames->At(0)))->GetName();
ac1671c0 1184 AliInfo(Form("The vertex will be taken from the background "
1185 "file %s with nSignalPerBackground = %d",
1186 fileName, signalPerBkgrd));
04bae0a0 1187 AliVertexGenFile* vtxGen = new AliVertexGenFile(fileName, signalPerBkgrd);
3e2e3ece 1188 gAlice->GetMCApp()->Generator()->SetVertexGenerator(vtxGen);
04bae0a0 1189 }
1190
85a5290f 1191 if (!fRunSimulation) {
3e2e3ece 1192 gAlice->GetMCApp()->Generator()->SetTrackingFlag(0);
85a5290f 1193 }
1194
18b43626 1195 // set the number of events per file for given detectors and data types
1196 for (Int_t i = 0; i < fEventsPerFile.GetEntriesFast(); i++) {
1197 if (!fEventsPerFile[i]) continue;
1198 const char* detName = fEventsPerFile[i]->GetName();
1199 const char* typeName = fEventsPerFile[i]->GetTitle();
1200 TString loaderName(detName);
1201 loaderName += "Loader";
1202 AliLoader* loader = runLoader->GetLoader(loaderName);
1203 if (!loader) {
65b25288 1204 AliError(Form("RunSimulation no loader for %s found\n Number of events per file not set for %s %s",
ac1671c0 1205 detName, typeName, detName));
18b43626 1206 continue;
1207 }
1208 AliDataLoader* dataLoader =
1209 loader->GetDataLoader(typeName);
1210 if (!dataLoader) {
ac1671c0 1211 AliError(Form("no data loader for %s found\n"
1212 "Number of events per file not set for %s %s",
1213 typeName, detName, typeName));
18b43626 1214 continue;
1215 }
1216 dataLoader->SetNumberOfEventsPerFile(fEventsPerFile[i]->GetUniqueID());
ac1671c0 1217 AliDebug(1, Form("number of events per file set to %d for %s %s",
1218 fEventsPerFile[i]->GetUniqueID(), detName, typeName));
18b43626 1219 }
1220
ac1671c0 1221 AliInfo("running gAlice");
6fcf567c 1222 AliSysInfo::AddStamp("Start_ProcessRun");
124253ee 1223
124253ee 1224 // Create the Root Tree with one branch per detector
1225 //Hits moved to begin event -> now we are crating separate tree for each event
124253ee 1226 gMC->ProcessRun(nEvents);
1227
1228 // End of this run, close files
3e2e3ece 1229 if(nEvents>0) FinishRun();
124253ee 1230
6fcf567c 1231 AliSysInfo::AddStamp("Stop_ProcessRun");
95601147 1232 delete runLoader;
85a5290f 1233
1234 return kTRUE;
1235}
1236
1237//_____________________________________________________________________________
35ec1f70 1238Bool_t AliSimulation::RunGeneratorOnly()
1239{
1240 // Execute Config.C
1241 TInterpreter::EErrorCode interpreterError=TInterpreter::kNoError;
1242 gROOT->LoadMacro(fConfigFileName.Data());
1243 Long_t interpreterResult=gInterpreter->ProcessLine(gAlice->GetConfigFunction(), &interpreterError);
1244 if (interpreterResult!=0 || interpreterError!=TInterpreter::kNoError) {
1245 AliFatal(Form("execution of config file \"%s\" failed with error %d", fConfigFileName.Data(), (int)interpreterError));
1246 }
1247
1248 // Setup the runloader and generator, check if everything is OK
1249 AliRunLoader* runLoader = AliRunLoader::Instance();
1250 AliGenerator* generator = gAlice->GetMCApp()->Generator();
1251 if (!runLoader) {
1252 AliError(Form("gAlice has no run loader object. "
1253 "Check your config file: %s", fConfigFileName.Data()));
1254 return kFALSE;
1255 }
1256 if (!generator) {
1257 AliError(Form("gAlice has no generator object. "
1258 "Check your config file: %s", fConfigFileName.Data()));
1259 return kFALSE;
1260 }
1261
1262 runLoader->LoadKinematics("RECREATE");
1263 runLoader->MakeTree("E");
1264
1265 // Create stack and header
1266 runLoader->MakeStack();
1267 AliStack* stack = runLoader->Stack();
1268 AliHeader* header = runLoader->GetHeader();
1269
1270 // Intialize generator
1271 generator->Init();
1272 generator->SetStack(stack);
1273
1274 // Run main generator loop
1275
1276 for (Int_t iev=0; iev<fNEvents; iev++)
1277 {
1278 // Initialize event
1279 header->Reset(0,iev);
1280 runLoader->SetEventNumber(iev);
1281 stack->Reset();
1282 runLoader->MakeTree("K");
1283
1284 // Generate event
1285 generator->Generate();
1286
1287 // Finish event
1288 header->SetNprimary(stack->GetNprimary());
1289 header->SetNtrack(stack->GetNtrack());
1290 stack->FinishEvent();
1291 header->SetStack(stack);
1292 runLoader->TreeE()->Fill();
1293 runLoader->WriteKinematics("OVERWRITE");
1294 }
1295
1296 // Finalize
1297 generator->FinishRun();
1298 // Write file
1299 runLoader->WriteHeader("OVERWRITE");
1300 generator->Write();
1301 runLoader->Write();
052ed86a 1302
1303 return kTRUE;
35ec1f70 1304}
1305
1306//_____________________________________________________________________________
95601147 1307Bool_t AliSimulation::RunSDigitization(const char* detectors)
85a5290f 1308{
1309// run the digitization and produce summable digits
27fc67fa 1310 static Int_t eventNr=0;
99c136e1 1311 AliCodeTimerAuto("",0) ;
4df28b43 1312
795e4a22 1313 // initialize CDB storage, run number, set CDB lock
1314 InitCDB();
1315 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
1316 SetCDBLock();
1317
95601147 1318 AliRunLoader* runLoader = LoadRun();
1319 if (!runLoader) return kFALSE;
1320
85a5290f 1321 TString detStr = detectors;
95601147 1322 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
85a5290f 1323 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1324 AliModule* det = (AliModule*) detArray->At(iDet);
1325 if (!det || !det->IsActive()) continue;
1326 if (IsSelected(det->GetName(), detStr)) {
ac1671c0 1327 AliInfo(Form("creating summable digits for %s", det->GetName()));
a899e40b 1328 AliCodeTimerStart(Form("creating summable digits for %s", det->GetName()));
85a5290f 1329 det->Hits2SDigits();
a899e40b 1330 AliCodeTimerStop(Form("creating summable digits for %s", det->GetName()));
27fc67fa 1331 AliSysInfo::AddStamp(Form("Digit_%s_%d",det->GetName(),eventNr), 0,1, eventNr);
85a5290f 1332 }
1333 }
1334
1335 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
ac1671c0 1336 AliError(Form("the following detectors were not found: %s",
1337 detStr.Data()));
85a5290f 1338 if (fStopOnError) return kFALSE;
1339 }
27fc67fa 1340 eventNr++;
95601147 1341 delete runLoader;
1342
85a5290f 1343 return kTRUE;
1344}
1345
1346
1347//_____________________________________________________________________________
95601147 1348Bool_t AliSimulation::RunDigitization(const char* detectors,
1349 const char* excludeDetectors)
85a5290f 1350{
1351// run the digitization and produce digits from sdigits
1352
99c136e1 1353 AliCodeTimerAuto("",0)
4df28b43 1354
795e4a22 1355 // initialize CDB storage, run number, set CDB lock
1356 InitCDB();
1357 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
1358 SetCDBLock();
1359
33c3c91a 1360 delete AliRunLoader::Instance();
124253ee 1361 delete gAlice;
95601147 1362 gAlice = NULL;
1363
1364 Int_t nStreams = 1;
05526d44 1365 if (fBkgrdFileNames) nStreams = fBkgrdFileNames->GetEntriesFast() + 1;
1366 Int_t signalPerBkgrd = GetNSignalPerBkgrd();
f21fc003 1367 AliDigitizationInput digInp(nStreams, signalPerBkgrd);
1368 // digInp.SetEmbeddingFlag(fEmbeddingFlag);
1369 digInp.SetRegionOfInterest(fRegionOfInterest);
1370 digInp.SetInputStream(0, fGAliceFileName.Data());
85a5290f 1371 for (Int_t iStream = 1; iStream < nStreams; iStream++) {
f21fc003 1372 const char* fileName = ((TObjString*)(fBkgrdFileNames->At(iStream-1)))->GetName();
1373 digInp.SetInputStream(iStream, fileName);
85a5290f 1374 }
f21fc003 1375 TObjArray detArr;
1376 detArr.SetOwner(kTRUE);
85a5290f 1377 TString detStr = detectors;
1378 TString detExcl = excludeDetectors;
f21fc003 1379 if (!static_cast<AliStream*>(digInp.GetInputStream(0))->ImportgAlice()) {
1380 AliError("Error occured while getting gAlice from Input 0");
1381 return kFALSE;
1382 }
1383 AliRunLoader* runLoader = AliRunLoader::GetRunLoader(digInp.GetInputStream(0)->GetFolderName());
95601147 1384 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
85a5290f 1385 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1386 AliModule* det = (AliModule*) detArray->At(iDet);
1387 if (!det || !det->IsActive()) continue;
f21fc003 1388 if (!IsSelected(det->GetName(), detStr) || IsSelected(det->GetName(), detExcl)) continue;
1389 AliDigitizer* digitizer = det->CreateDigitizer(&digInp);
1390 if (!digitizer || !digitizer->Init()) {
1391 AliError(Form("no digitizer for %s", det->GetName()));
1392 if (fStopOnError) return kFALSE;
1393 else continue;
85a5290f 1394 }
f21fc003 1395 detArr.AddLast(digitizer);
1396 AliInfo(Form("Created digitizer from SDigits -> Digits for %s", det->GetName()));
85a5290f 1397 }
f21fc003 1398 //
85a5290f 1399 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
f21fc003 1400 AliError(Form("the following detectors were not found: %s", detStr.Data()));
85a5290f 1401 if (fStopOnError) return kFALSE;
1402 }
f21fc003 1403 //
1404 Int_t ndigs = detArr.GetEntriesFast();
1405 Int_t eventsCreated = 0;
1406 AliRunLoader* outRl = digInp.GetOutRunLoader();
1407 while ((eventsCreated++ < fNEvents) || (fNEvents < 0)) {
1408 if (!digInp.ConnectInputTrees()) break;
1409 digInp.InitEvent(); //this must be after call of Connect Input tress.
1410 if (outRl) outRl->SetEventNumber(eventsCreated-1);
1411 static_cast<AliStream*>(digInp.GetInputStream(0))->ImportgAlice(); // use gAlice of the first input stream
1412 for (int id=0;id<ndigs;id++) ((AliDigitizer*)detArr[id])->Digitize("");
1413 digInp.FinishEvent();
1414 };
1415 digInp.FinishGlobal();
1416 //
85a5290f 1417 return kTRUE;
1418}
1419
1420//_____________________________________________________________________________
95601147 1421Bool_t AliSimulation::RunHitsDigitization(const char* detectors)
85a5290f 1422{
1423// run the digitization and produce digits from hits
1424
99c136e1 1425 AliCodeTimerAuto("",0)
4df28b43 1426
795e4a22 1427 // initialize CDB storage, run number, set CDB lock
1428 InitCDB();
1429 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
1430 SetCDBLock();
1431
591f51bb 1432 AliRunLoader* runLoader = LoadRun("READ");
95601147 1433 if (!runLoader) return kFALSE;
1434
85a5290f 1435 TString detStr = detectors;
95601147 1436 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
85a5290f 1437 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1438 AliModule* det = (AliModule*) detArray->At(iDet);
1439 if (!det || !det->IsActive()) continue;
1440 if (IsSelected(det->GetName(), detStr)) {
ac1671c0 1441 AliInfo(Form("creating digits from hits for %s", det->GetName()));
85a5290f 1442 det->Hits2Digits();
1443 }
1444 }
1445
1446 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
ac1671c0 1447 AliError(Form("the following detectors were not found: %s",
1448 detStr.Data()));
85a5290f 1449 if (fStopOnError) return kFALSE;
1450 }
1451
1452 return kTRUE;
1453}
1454
0421c3d1 1455//_____________________________________________________________________________
06c7e392 1456Bool_t AliSimulation::WriteRawData(const char* detectors,
1457 const char* fileName,
67327b72 1458 Bool_t deleteIntermediateFiles,
1459 Bool_t selrawdata)
0421c3d1 1460{
1461// convert the digits to raw data
06c7e392 1462// First DDL raw data files for the given detectors are created.
1463// If a file name is given, the DDL files are then converted to a DATE file.
1464// If deleteIntermediateFiles is true, the DDL raw files are deleted
1465// afterwards.
1466// If the file name has the extension ".root", the DATE file is converted
1467// to a root file.
1468// If deleteIntermediateFiles is true, the DATE file is deleted afterwards.
67327b72 1469// 'selrawdata' flag can be used to enable writing of detectors raw data
1470// accoring to the trigger cluster.
0421c3d1 1471
99c136e1 1472 AliCodeTimerAuto("",0)
6fcf567c 1473 AliSysInfo::AddStamp("WriteRawData_Start");
4cce3e4e 1474
1475 TString detStr = detectors;
4cce3e4e 1476 if (!WriteRawFiles(detStr.Data())) {
06c7e392 1477 if (fStopOnError) return kFALSE;
1478 }
6fcf567c 1479 AliSysInfo::AddStamp("WriteRawFiles");
06c7e392 1480
5f6d0c0d 1481 // run HLT simulation on simulated DDL raw files
1482 // and produce HLT ddl raw files to be included in date/root file
c4affb19 1483 // bugfix 2009-06-26: the decision whether to write HLT raw data
1484 // is taken in RunHLT. Here HLT always needs to be run in order to
1485 // create HLT digits, unless its switched off. This is due to the
1486 // special placement of the HLT between the generation of DDL files
1487 // and conversion to DATE/Root file.
1488 detStr.ReplaceAll("HLT", "");
1489 if (!fRunHLT.IsNull()) {
5f6d0c0d 1490 if (!RunHLT()) {
1491 if (fStopOnError) return kFALSE;
1492 }
1493 }
6fcf567c 1494 AliSysInfo::AddStamp("WriteRawData_RunHLT");
5f6d0c0d 1495
06c7e392 1496 TString dateFileName(fileName);
1497 if (!dateFileName.IsNull()) {
1498 Bool_t rootOutput = dateFileName.EndsWith(".root");
1499 if (rootOutput) dateFileName += ".date";
67327b72 1500 TString selDateFileName;
1501 if (selrawdata) {
1502 selDateFileName = "selected.";
1503 selDateFileName+= dateFileName;
1504 }
1505 if (!ConvertRawFilesToDate(dateFileName,selDateFileName)) {
06c7e392 1506 if (fStopOnError) return kFALSE;
1507 }
6fcf567c 1508 AliSysInfo::AddStamp("ConvertRawFilesToDate");
06c7e392 1509 if (deleteIntermediateFiles) {
1510 AliRunLoader* runLoader = LoadRun("READ");
1511 if (runLoader) for (Int_t iEvent = 0;
1512 iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
1513 char command[256];
76880c9a 1514 snprintf(command, 256, "rm -r raw%d", iEvent);
06c7e392 1515 gSystem->Exec(command);
1516 }
a978141c 1517 delete runLoader;
06c7e392 1518 }
1519
1520 if (rootOutput) {
1521 if (!ConvertDateToRoot(dateFileName, fileName)) {
1522 if (fStopOnError) return kFALSE;
1523 }
6fcf567c 1524 AliSysInfo::AddStamp("ConvertDateToRoot");
06c7e392 1525 if (deleteIntermediateFiles) {
1526 gSystem->Unlink(dateFileName);
1527 }
67327b72 1528 if (selrawdata) {
1529 TString selFileName = "selected.";
1530 selFileName += fileName;
1531 if (!ConvertDateToRoot(selDateFileName, selFileName)) {
1532 if (fStopOnError) return kFALSE;
1533 }
1534 if (deleteIntermediateFiles) {
1535 gSystem->Unlink(selDateFileName);
1536 }
1537 }
06c7e392 1538 }
1539 }
1540
06c7e392 1541 return kTRUE;
1542}
1543
1544//_____________________________________________________________________________
1545Bool_t AliSimulation::WriteRawFiles(const char* detectors)
1546{
1547// convert the digits to raw data DDL files
1548
99c136e1 1549 AliCodeTimerAuto("",0)
87932dab 1550
06c7e392 1551 AliRunLoader* runLoader = LoadRun("READ");
0421c3d1 1552 if (!runLoader) return kFALSE;
1553
06c7e392 1554 // write raw data to DDL files
0421c3d1 1555 for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
ac1671c0 1556 AliInfo(Form("processing event %d", iEvent));
0421c3d1 1557 runLoader->GetEvent(iEvent);
1558 TString baseDir = gSystem->WorkingDirectory();
1559 char dirName[256];
76880c9a 1560 snprintf(dirName, 256, "raw%d", iEvent);
0421c3d1 1561 gSystem->MakeDirectory(dirName);
1562 if (!gSystem->ChangeDirectory(dirName)) {
ac1671c0 1563 AliError(Form("couldn't change to directory %s", dirName));
0421c3d1 1564 if (fStopOnError) return kFALSE; else continue;
1565 }
1566
3fbd60fe 1567 ofstream runNbFile(Form("run%u",runLoader->GetHeader()->GetRun()));
1568 runNbFile.close();
1569
0421c3d1 1570 TString detStr = detectors;
5f6d0c0d 1571 if (IsSelected("HLT", detStr)) {
1572 // Do nothing. "HLT" will be removed from detStr and HLT raw
1573 // data files are generated in RunHLT.
1574 }
1575
0421c3d1 1576 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1577 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1578 AliModule* det = (AliModule*) detArray->At(iDet);
1579 if (!det || !det->IsActive()) continue;
1580 if (IsSelected(det->GetName(), detStr)) {
ac1671c0 1581 AliInfo(Form("creating raw data from digits for %s", det->GetName()));
0421c3d1 1582 det->Digits2Raw();
1583 }
1584 }
1585
007155cc 1586 if (!WriteTriggerRawData())
1587 if (fStopOnError) return kFALSE;
1588
0421c3d1 1589 gSystem->ChangeDirectory(baseDir);
1590 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
ac1671c0 1591 AliError(Form("the following detectors were not found: %s",
1592 detStr.Data()));
0421c3d1 1593 if (fStopOnError) return kFALSE;
1594 }
1595 }
1596
1597 delete runLoader;
87932dab 1598
06c7e392 1599 return kTRUE;
1600}
0421c3d1 1601
06c7e392 1602//_____________________________________________________________________________
67327b72 1603Bool_t AliSimulation::ConvertRawFilesToDate(const char* dateFileName,
1604 const char* selDateFileName)
06c7e392 1605{
1606// convert raw data DDL files to a DATE file with the program "dateStream"
67327b72 1607// The second argument is not empty when the user decides to write
1608// the detectors raw data according to the trigger cluster.
06c7e392 1609
99c136e1 1610 AliCodeTimerAuto("",0)
87932dab 1611
06c7e392 1612 char* path = gSystem->Which(gSystem->Getenv("PATH"), "dateStream");
1613 if (!path) {
ac1671c0 1614 AliError("the program dateStream was not found");
06c7e392 1615 if (fStopOnError) return kFALSE;
1616 } else {
1617 delete[] path;
1618 }
0421c3d1 1619
06c7e392 1620 AliRunLoader* runLoader = LoadRun("READ");
1621 if (!runLoader) return kFALSE;
1622
ac1671c0 1623 AliInfo(Form("converting raw data DDL files to DATE file %s", dateFileName));
67327b72 1624 Bool_t selrawdata = kFALSE;
1625 if (strcmp(selDateFileName,"") != 0) selrawdata = kTRUE;
1626
06c7e392 1627 char command[256];
f28a8d2d 1628 // Note the option -s. It is used in order to avoid
1629 // the generation of SOR/EOR events.
76880c9a 1630 snprintf(command, 256, "dateStream -c -s -D -o %s -# %d -C -run %d",
5c0fd670 1631 dateFileName, runLoader->GetNumberOfEvents(),runLoader->GetHeader()->GetRun());
06c7e392 1632 FILE* pipe = gSystem->OpenPipe(command, "w");
1633
f5e7d9d8 1634 if (!pipe) {
1635 AliError(Form("Cannot execute command: %s",command));
1636 return kFALSE;
1637 }
1638
67327b72 1639 Int_t selEvents = 0;
06c7e392 1640 for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
06c7e392 1641
f59c50c6 1642 UInt_t detectorPattern = 0;
1643 runLoader->GetEvent(iEvent);
1644 if (!runLoader->LoadTrigger()) {
1645 AliCentralTrigger *aCTP = runLoader->GetTrigger();
1646 detectorPattern = aCTP->GetClusterMask();
67327b72 1647 // Check if the event was triggered by CTP
f59c50c6 1648 if (selrawdata) {
67327b72 1649 if (aCTP->GetClassMask()) selEvents++;
1650 }
f59c50c6 1651 }
1652 else {
1653 AliWarning("No trigger can be loaded! Some fields in the event header will be empty !");
1654 if (selrawdata) {
67327b72 1655 AliWarning("No trigger can be loaded! Writing of selected raw data is abandoned !");
1656 selrawdata = kFALSE;
1657 }
1658 }
1659
dcf4b43a 1660 fprintf(pipe, "GDC DetectorPattern %u Timestamp %ld\n", detectorPattern, runLoader->GetHeader()->GetTimeStamp());
f59c50c6 1661 Float_t ldc = 0;
1662 Int_t prevLDC = -1;
1663
06c7e392 1664 // loop over detectors and DDLs
362c9d61 1665 for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
1666 for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls(iDet); iDDL++) {
06c7e392 1667
362c9d61 1668 Int_t ddlID = AliDAQ::DdlID(iDet,iDDL);
06c7e392 1669 Int_t ldcID = Int_t(ldc + 0.0001);
362c9d61 1670 ldc += AliDAQ::NumberOfLdcs(iDet) / AliDAQ::NumberOfDdls(iDet);
06c7e392 1671
1672 char rawFileName[256];
76880c9a 1673 snprintf(rawFileName, 256, "raw%d/%s",
362c9d61 1674 iEvent, AliDAQ::DdlFileName(iDet,iDDL));
06c7e392 1675
1676 // check existence and size of raw data file
1677 FILE* file = fopen(rawFileName, "rb");
1678 if (!file) continue;
1679 fseek(file, 0, SEEK_END);
1680 unsigned long size = ftell(file);
aa04f81b 1681 fclose(file);
1682 if (!size) continue;
06c7e392 1683
1684 if (ldcID != prevLDC) {
1685 fprintf(pipe, " LDC Id %d\n", ldcID);
1686 prevLDC = ldcID;
1687 }
1688 fprintf(pipe, " Equipment Id %d Payload %s\n", ddlID, rawFileName);
1689 }
1690 }
1691 }
1692
1693 Int_t result = gSystem->ClosePipe(pipe);
1694
cf30933c 1695 if (!(selrawdata && selEvents > 0)) {
67327b72 1696 delete runLoader;
1697 return (result == 0);
1698 }
1699
1700 AliInfo(Form("converting selected by trigger cluster raw data DDL files to DATE file %s", selDateFileName));
1701
76880c9a 1702 snprintf(command, 256, "dateStream -c -s -D -o %s -# %d -C -run %d",
67327b72 1703 selDateFileName,selEvents,runLoader->GetHeader()->GetRun());
1704 FILE* pipe2 = gSystem->OpenPipe(command, "w");
1705
1706 for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
1707
1708 // Get the trigger decision and cluster
f59c50c6 1709 UInt_t detectorPattern = 0;
67327b72 1710 TString detClust;
1711 runLoader->GetEvent(iEvent);
1712 if (!runLoader->LoadTrigger()) {
1713 AliCentralTrigger *aCTP = runLoader->GetTrigger();
1714 if (aCTP->GetClassMask() == 0) continue;
f59c50c6 1715 detectorPattern = aCTP->GetClusterMask();
1716 detClust = AliDAQ::ListOfTriggeredDetectors(detectorPattern);
67327b72 1717 AliInfo(Form("List of detectors to be read out: %s",detClust.Data()));
1718 }
1719
dcf4b43a 1720 fprintf(pipe2, "GDC DetectorPattern %u Timestamp %ld\n", detectorPattern, runLoader->GetHeader()->GetTimeStamp());
67327b72 1721 Float_t ldc = 0;
1722 Int_t prevLDC = -1;
1723
1724 // loop over detectors and DDLs
1725 for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
1726 // Write only raw data from detectors that
1727 // are contained in the trigger cluster(s)
1728 if (!IsSelected(AliDAQ::DetectorName(iDet),detClust)) continue;
1729
1730 for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls(iDet); iDDL++) {
1731
1732 Int_t ddlID = AliDAQ::DdlID(iDet,iDDL);
1733 Int_t ldcID = Int_t(ldc + 0.0001);
1734 ldc += AliDAQ::NumberOfLdcs(iDet) / AliDAQ::NumberOfDdls(iDet);
1735
1736 char rawFileName[256];
76880c9a 1737 snprintf(rawFileName, 256, "raw%d/%s",
67327b72 1738 iEvent, AliDAQ::DdlFileName(iDet,iDDL));
1739
1740 // check existence and size of raw data file
1741 FILE* file = fopen(rawFileName, "rb");
1742 if (!file) continue;
1743 fseek(file, 0, SEEK_END);
1744 unsigned long size = ftell(file);
1745 fclose(file);
1746 if (!size) continue;
1747
1748 if (ldcID != prevLDC) {
1749 fprintf(pipe2, " LDC Id %d\n", ldcID);
1750 prevLDC = ldcID;
1751 }
1752 fprintf(pipe2, " Equipment Id %d Payload %s\n", ddlID, rawFileName);
1753 }
1754 }
1755 }
1756
1757 Int_t result2 = gSystem->ClosePipe(pipe2);
1758
06c7e392 1759 delete runLoader;
67327b72 1760 return ((result == 0) && (result2 == 0));
06c7e392 1761}
1762
1763//_____________________________________________________________________________
1764Bool_t AliSimulation::ConvertDateToRoot(const char* dateFileName,
1765 const char* rootFileName)
1766{
1767// convert a DATE file to a root file with the program "alimdc"
1768
1769 // ALIMDC setup
f28a8d2d 1770 const Int_t kDBSize = 2000000000;
c83eb8f4 1771 const Int_t kTagDBSize = 1000000000;
06c7e392 1772 const Bool_t kFilter = kFALSE;
8ec1d12b 1773 const Int_t kCompression = 1;
06c7e392 1774
1775 char* path = gSystem->Which(gSystem->Getenv("PATH"), "alimdc");
1776 if (!path) {
ac1671c0 1777 AliError("the program alimdc was not found");
06c7e392 1778 if (fStopOnError) return kFALSE;
1779 } else {
1780 delete[] path;
1781 }
1782
ac1671c0 1783 AliInfo(Form("converting DATE file %s to root file %s",
1784 dateFileName, rootFileName));
06c7e392 1785
f732bd7d 1786 const char* rawDBFS[2] = { "/tmp/mdc1", "/tmp/mdc2" };
1787 const char* tagDBFS = "/tmp/mdc1/tags";
f732bd7d 1788
1789 // User defined file system locations
1790 if (gSystem->Getenv("ALIMDC_RAWDB1"))
1791 rawDBFS[0] = gSystem->Getenv("ALIMDC_RAWDB1");
1792 if (gSystem->Getenv("ALIMDC_RAWDB2"))
1793 rawDBFS[1] = gSystem->Getenv("ALIMDC_RAWDB2");
1794 if (gSystem->Getenv("ALIMDC_TAGDB"))
1795 tagDBFS = gSystem->Getenv("ALIMDC_TAGDB");
f732bd7d 1796
1797 gSystem->Exec(Form("rm -rf %s",rawDBFS[0]));
1798 gSystem->Exec(Form("rm -rf %s",rawDBFS[1]));
1799 gSystem->Exec(Form("rm -rf %s",tagDBFS));
f732bd7d 1800
1801 gSystem->Exec(Form("mkdir %s",rawDBFS[0]));
1802 gSystem->Exec(Form("mkdir %s",rawDBFS[1]));
1803 gSystem->Exec(Form("mkdir %s",tagDBFS));
f732bd7d 1804
1805 Int_t result = gSystem->Exec(Form("alimdc %d %d %d %d %s",
1806 kDBSize, kTagDBSize, kFilter, kCompression, dateFileName));
1807 gSystem->Exec(Form("mv %s/*.root %s", rawDBFS[0], rootFileName));
1808
1809 gSystem->Exec(Form("rm -rf %s",rawDBFS[0]));
1810 gSystem->Exec(Form("rm -rf %s",rawDBFS[1]));
1811 gSystem->Exec(Form("rm -rf %s",tagDBFS));
06c7e392 1812
1813 return (result == 0);
0421c3d1 1814}
1815
85a5290f 1816
1817//_____________________________________________________________________________
06c7e392 1818AliRunLoader* AliSimulation::LoadRun(const char* mode) const
95601147 1819{
1820// delete existing run loaders, open a new one and load gAlice
1821
33c3c91a 1822 delete AliRunLoader::Instance();
95601147 1823 AliRunLoader* runLoader =
1824 AliRunLoader::Open(fGAliceFileName.Data(),
06c7e392 1825 AliConfig::GetDefaultEventFolderName(), mode);
95601147 1826 if (!runLoader) {
ac1671c0 1827 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
95601147 1828 return NULL;
1829 }
1830 runLoader->LoadgAlice();
795e4a22 1831 runLoader->LoadHeader();
95601147 1832 gAlice = runLoader->GetAliRun();
1833 if (!gAlice) {
ac1671c0 1834 AliError(Form("no gAlice object found in file %s",
1835 fGAliceFileName.Data()));
95601147 1836 return NULL;
1837 }
1838 return runLoader;
1839}
1840
1841//_____________________________________________________________________________
05526d44 1842Int_t AliSimulation::GetNSignalPerBkgrd(Int_t nEvents) const
1843{
1844// get or calculate the number of signal events per background event
1845
1846 if (!fBkgrdFileNames) return 1;
1847 Int_t nBkgrdFiles = fBkgrdFileNames->GetEntriesFast();
1848 if (nBkgrdFiles == 0) return 1;
1849
1850 // get the number of signal events
1851 if (nEvents <= 0) {
1852 AliRunLoader* runLoader =
ca30848f 1853 AliRunLoader::Open(fGAliceFileName.Data(), "SIGNAL");
05526d44 1854 if (!runLoader) return 1;
ca30848f 1855
05526d44 1856 nEvents = runLoader->GetNumberOfEvents();
1857 delete runLoader;
1858 }
1859
1860 Int_t result = 0;
1861 for (Int_t iBkgrdFile = 0; iBkgrdFile < nBkgrdFiles; iBkgrdFile++) {
1862 // get the number of background events
1863 const char* fileName = ((TObjString*)
1864 (fBkgrdFileNames->At(iBkgrdFile)))->GetName();
ca30848f 1865 AliRunLoader* runLoader =
05526d44 1866 AliRunLoader::Open(fileName, "BKGRD");
1867 if (!runLoader) continue;
1868 Int_t nBkgrdEvents = runLoader->GetNumberOfEvents();
1869 delete runLoader;
ca30848f 1870
05526d44 1871 // get or calculate the number of signal per background events
1872 Int_t nSignalPerBkgrd = fBkgrdFileNames->At(iBkgrdFile)->GetUniqueID();
1873 if (nSignalPerBkgrd <= 0) {
1874 nSignalPerBkgrd = (nEvents-1) / nBkgrdEvents + 1;
1875 } else if (result && (result != nSignalPerBkgrd)) {
ac1671c0 1876 AliInfo(Form("the number of signal events per background event "
1877 "will be changed from %d to %d for stream %d",
1878 nSignalPerBkgrd, result, iBkgrdFile+1));
05526d44 1879 nSignalPerBkgrd = result;
1880 }
1881
1882 if (!result) result = nSignalPerBkgrd;
1883 if (nSignalPerBkgrd * nBkgrdEvents < nEvents) {
ac1671c0 1884 AliWarning(Form("not enough background events (%d) for %d signal events "
1885 "using %d signal per background events for stream %d",
1886 nBkgrdEvents, nEvents, nSignalPerBkgrd, iBkgrdFile+1));
05526d44 1887 }
1888 }
1889
1890 return result;
1891}
1892
1893//_____________________________________________________________________________
85a5290f 1894Bool_t AliSimulation::IsSelected(TString detName, TString& detectors) const
1895{
1896// check whether detName is contained in detectors
1897// if yes, it is removed from detectors
1898
1899 // check if all detectors are selected
1900 if ((detectors.CompareTo("ALL") == 0) ||
1901 detectors.BeginsWith("ALL ") ||
1902 detectors.EndsWith(" ALL") ||
1903 detectors.Contains(" ALL ")) {
1904 detectors = "ALL";
1905 return kTRUE;
1906 }
1907
1908 // search for the given detector
1909 Bool_t result = kFALSE;
1910 if ((detectors.CompareTo(detName) == 0) ||
1911 detectors.BeginsWith(detName+" ") ||
1912 detectors.EndsWith(" "+detName) ||
1913 detectors.Contains(" "+detName+" ")) {
1914 detectors.ReplaceAll(detName, "");
1915 result = kTRUE;
1916 }
1917
1918 // clean up the detectors string
1919 while (detectors.Contains(" ")) detectors.ReplaceAll(" ", " ");
1920 while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
1921 while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
1922
1923 return result;
1924}
ca30848f 1925
795e4a22 1926//_____________________________________________________________________________
c95d53ea 1927Int_t AliSimulation::ConvertRaw2SDigits(const char* rawDirectory, const char* esdFileName, Int_t N, Int_t nSkip)
ca30848f 1928{
1929//
1930// Steering routine to convert raw data in directory rawDirectory/ to fake SDigits.
1931// These can be used for embedding of MC tracks into RAW data using the standard
1932// merging procedure.
1933//
1934// If an ESD file is given the reconstructed vertex is taken from it and stored in the event header.
1935//
3e2e3ece 1936 if (!gAlice) {
1937 AliError("no gAlice object. Restart aliroot and try again.");
1938 return kFALSE;
1939 }
1940 if (gAlice->Modules()->GetEntries() > 0) {
1941 AliError("gAlice was already run. Restart aliroot and try again.");
1942 return kFALSE;
1943 }
1944
1945 AliInfo(Form("initializing gAlice with config file %s",fConfigFileName.Data()));
1946
1947 gAlice->Announce();
1948
1949 gROOT->LoadMacro(fConfigFileName.Data());
1950 gInterpreter->ProcessLine(gAlice->GetConfigFunction());
1951
1952 if(AliCDBManager::Instance()->GetRun() >= 0) {
1953 SetRunNumber(AliCDBManager::Instance()->GetRun());
1954 } else {
1955 AliWarning("Run number not initialized!!");
1956 }
1957
33c3c91a 1958 AliRunLoader::Instance()->CdGAFile();
ca30848f 1959
3e2e3ece 1960 AliPDG::AddParticlesToPdgDataBase();
1961
f7a1cc68 1962 gMC->SetMagField(TGeoGlobalMagField::Instance()->GetField());
3e2e3ece 1963
55338a9a 1964 gAlice->GetMCApp()->Init();
1965
3e2e3ece 1966 //Must be here because some MCs (G4) adds detectors here and not in Config.C
1967 gAlice->InitLoaders();
33c3c91a 1968 AliRunLoader::Instance()->MakeTree("E");
1969 AliRunLoader::Instance()->LoadKinematics("RECREATE");
1970 AliRunLoader::Instance()->LoadTrackRefs("RECREATE");
1971 AliRunLoader::Instance()->LoadHits("all","RECREATE");
2eab8cf7 1972
3e2e3ece 1973 //
1974 // Save stuff at the beginning of the file to avoid file corruption
33c3c91a 1975 AliRunLoader::Instance()->CdGAFile();
3e2e3ece 1976 gAlice->Write();
ca30848f 1977//
1978// Initialize CDB
795e4a22 1979 InitCDB();
1980 //AliCDBManager* man = AliCDBManager::Instance();
1981 //man->SetRun(0); // Should this come from rawdata header ?
ca30848f 1982
1983 Int_t iDet;
1984 //
1985 // Get the runloader
33c3c91a 1986 AliRunLoader* runLoader = AliRunLoader::Instance();
ca30848f 1987 //
1988 // Open esd file if available
a77627a4 1989 TFile* esdFile = 0;
ca30848f 1990 TTree* treeESD = 0;
a77627a4 1991 AliESDEvent* esd = 0;
2eab8cf7 1992 if (esdFileName && (strlen(esdFileName)>0)) {
a77627a4 1993 esdFile = TFile::Open(esdFileName);
1994 if (esdFile) {
1995 esd = new AliESDEvent();
1996 esdFile->GetObject("esdTree", treeESD);
c95d53ea 1997 if (treeESD) {
1998 esd->ReadFromTree(treeESD);
1999 if (nSkip>0) {
2000 AliInfo(Form("Asking to skip first %d ESDs events",nSkip));
2001 } else {
2002 nSkip=0;
2003 }
2004 }
a77627a4 2005 }
2006 }
6d985680 2007
ca30848f 2008 //
2009 // Create the RawReader
8b31e840 2010 TString fileName(rawDirectory);
5390a0b4 2011 AliRawReader* rawReader = AliRawReader::Create(fileName.Data());
58c338d2 2012 if (!rawReader) return (kFALSE);
2013
8b31e840 2014// if (!fEquipIdMap.IsNull() && fRawReader)
2015// fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
ca30848f 2016 //
2017 // Get list of detectors
2018 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
2019 //
2020 // Get Header
2021 AliHeader* header = runLoader->GetHeader();
ca30848f 2022 // Event loop
2023 Int_t nev = 0;
2024 while(kTRUE) {
2025 if (!(rawReader->NextEvent())) break;
b2f03502 2026 runLoader->SetEventNumber(nev);
2027 runLoader->GetHeader()->Reset(rawReader->GetRunNumber(),
2028 nev, nev);
b2f03502 2029 runLoader->GetEvent(nev);
2eab8cf7 2030 AliInfo(Form("We are at event %d",nev));
ca30848f 2031 //
2032 // Detector loop
b2f03502 2033 TString detStr = fMakeSDigits;
ca30848f 2034 for (iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
2035 AliModule* det = (AliModule*) detArray->At(iDet);
8b31e840 2036 if (!det || !det->IsActive()) continue;
2037 if (IsSelected(det->GetName(), detStr)) {
2eab8cf7 2038 AliInfo(Form("Calling Raw2SDigits for %s", det->GetName()));
8b31e840 2039 det->Raw2SDigits(rawReader);
2040 rawReader->Reset();
2041 }
ca30848f 2042 } // detectors
b2f03502 2043
5b188f2f 2044
ca30848f 2045 //
2046 // If ESD information available obtain reconstructed vertex and store in header.
6d985680 2047 if (treeESD) {
c95d53ea 2048 AliInfo(Form("Selected event %d correspond to event %d in raw and to %d in esd",nev,rawReader->GetEventIndex(),nSkip+rawReader->GetEventIndex()));
2049 treeESD->GetEvent(nSkip+rawReader->GetEventIndex());
ca30848f 2050 const AliESDVertex* esdVertex = esd->GetPrimaryVertex();
2051 Double_t position[3];
2052 esdVertex->GetXYZ(position);
2053 AliGenEventHeader* mcHeader = new AliGenEventHeader("ESD");
2054 TArrayF mcV;
2055 mcV.Set(3);
2056 for (Int_t i = 0; i < 3; i++) mcV[i] = position[i];
2057 mcHeader->SetPrimaryVertex(mcV);
2058 header->Reset(0,nev);
2059 header->SetGenEventHeader(mcHeader);
2eab8cf7 2060 AliInfo(Form("***** Saved vertex %f %f %f \n", position[0], position[1], position[2]));
ca30848f 2061 }
ca30848f 2062//
2063// Finish the event
2d9bb909 2064 runLoader->TreeE()->Fill();
2eab8cf7 2065 AliInfo(Form("Finished event %d",nev));
b2f03502 2066 nev++;
2eab8cf7 2067 if (N>0&&nev>=N)
2068 break;
ca30848f 2069 } // events
2070
2071 delete rawReader;
2072//
2073// Finish the run
2074 runLoader->CdGAFile();
2075 runLoader->WriteHeader("OVERWRITE");
2076 runLoader->WriteRunLoader();
2077
5390a0b4 2078 return nev;
ca30848f 2079}
5b188f2f 2080
2081//_____________________________________________________________________________
3e2e3ece 2082void AliSimulation::FinishRun()
2083{
2084 //
2085 // Called at the end of the run.
2086 //
2087
2088 if(IsLegoRun())
2089 {
2090 AliDebug(1, "Finish Lego");
33c3c91a 2091 AliRunLoader::Instance()->CdGAFile();
3e2e3ece 2092 fLego->FinishRun();
2093 }
2094
2095 // Clean detector information
2096 TIter next(gAlice->Modules());
2097 AliModule *detector;
2098 while((detector = dynamic_cast<AliModule*>(next()))) {
2099 AliDebug(2, Form("%s->FinishRun()", detector->GetName()));
2100 detector->FinishRun();
2101 }
2102
33c3c91a 2103 AliDebug(1, "AliRunLoader::Instance()->WriteHeader(OVERWRITE)");
2104 AliRunLoader::Instance()->WriteHeader("OVERWRITE");
3e2e3ece 2105
2106 // Write AliRun info and all detectors parameters
33c3c91a 2107 AliRunLoader::Instance()->CdGAFile();
3e2e3ece 2108 gAlice->Write(0,TObject::kOverwrite);//write AliRun
33c3c91a 2109 AliRunLoader::Instance()->Write(0,TObject::kOverwrite);//write RunLoader itself
8e940b8f 2110 //
2111 StoreUsedCDBMaps();
2112 //
3e2e3ece 2113 if(gAlice->GetMCApp()) gAlice->GetMCApp()->FinishRun();
33c3c91a 2114 AliRunLoader::Instance()->Synchronize();
3e2e3ece 2115}
2116
2117//_____________________________________________________________________________
5b188f2f 2118Int_t AliSimulation::GetDetIndex(const char* detector)
2119{
2120 // return the detector index corresponding to detector
2121 Int_t index = -1 ;
2122 for (index = 0; index < fgkNDetectors ; index++) {
2123 if ( strcmp(detector, fgkDetectorName[index]) == 0 )
2124 break ;
2125 }
2126 return index ;
2127}
cae21299 2128
2129//_____________________________________________________________________________
c4affb19 2130Bool_t AliSimulation::CreateHLT()
2131{
2132 // Init the HLT simulation.
2133 // The function loads the library and creates the instance of AliHLTSimulation.
2134 // the main reason for the decoupled creation is to set the transient OCDB
2135 // objects before the OCDB is locked
2136
2137 // load the library dynamically
2138 gSystem->Load(ALIHLTSIMULATION_LIBRARY);
2139
2140 // check for the library version
2141 AliHLTSimulationGetLibraryVersion_t fctVersion=(AliHLTSimulationGetLibraryVersion_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_GET_LIBRARY_VERSION));
2142 if (!fctVersion) {
2143 AliError(Form("can not load library %s", ALIHLTSIMULATION_LIBRARY));
2144 return kFALSE;
2145 }
2146 if (fctVersion()!= ALIHLTSIMULATION_LIBRARY_VERSION) {
b682a4ec 2147 AliWarning(Form("%s version does not match: compiled for version %d, loaded %d", ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_LIBRARY_VERSION, fctVersion()));
c4affb19 2148 }
2149
2150 // print compile info
2151 typedef void (*CompileInfo)( const char*& date, const char*& time);
2152 CompileInfo fctInfo=(CompileInfo)gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, "CompileInfo");
2153 if (fctInfo) {
2154 const char* date="";
2155 const char* time="";
2156 (*fctInfo)(date, time);
2157 if (!date) date="unknown";
2158 if (!time) time="unknown";
2159 AliInfo(Form("%s build on %s (%s)", ALIHLTSIMULATION_LIBRARY, date, time));
2160 } else {
2161 AliInfo(Form("no build info available for %s", ALIHLTSIMULATION_LIBRARY));
2162 }
2163
2164 // create instance of the HLT simulation
2165 AliHLTSimulationCreateInstance_t fctCreate=(AliHLTSimulationCreateInstance_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_CREATE_INSTANCE));
2166 if (fctCreate==NULL || (fpHLT=(fctCreate()))==NULL) {
2167 AliError(Form("can not create instance of HLT simulation (creator %p)", fctCreate));
2168 return kFALSE;
2169 }
2170
2171 TString specObjects;
2172 for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
2173 if (specObjects.Length()>0) specObjects+=" ";
2174 specObjects+=fSpecCDBUri[i]->GetName();
2175 }
2176
2177 AliHLTSimulationSetup_t fctSetup=(AliHLTSimulationSetup_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_SETUP));
2178 if (fctSetup==NULL || fctSetup(fpHLT, this, specObjects.Data())<0) {
2179 AliWarning(Form("failed to setup HLT simulation (function %p)", fctSetup));
2180 }
2181
2182 return kTRUE;
2183}
2184
2185//_____________________________________________________________________________
cae21299 2186Bool_t AliSimulation::RunHLT()
2187{
2188 // Run the HLT simulation
2189 // HLT simulation is implemented in HLT/sim/AliHLTSimulation
2190 // Disabled if fRunHLT is empty, default vaule is "default".
2191 // AliSimulation::SetRunHLT can be used to set the options for HLT simulation
2192 // The default simulation depends on the HLT component libraries and their
2193 // corresponding agents which define components and chains to run. See
5f6d0c0d 2194 // http://web.ift.uib.no/~kjeks/doc/alice-hlt-current/
2195 // http://web.ift.uib.no/~kjeks/doc/alice-hlt-current/classAliHLTModuleAgent.html
cae21299 2196 //
2197 // The libraries to be loaded can be specified as an option.
2198 // <pre>
2199 // AliSimulation sim;
2200 // sim.SetRunHLT("libAliHLTSample.so");
2201 // </pre>
2202 // will only load <tt>libAliHLTSample.so</tt>
2203
2204 // Other available options:
2205 // \li loglevel=<i>level</i> <br>
2206 // logging level for this processing
2207 // \li alilog=off
2208 // disable redirection of log messages to AliLog class
2209 // \li config=<i>macro</i>
2210 // configuration macro
5f6d0c0d 2211 // \li chains=<i>configuration</i>
cae21299 2212 // comma separated list of configurations to be run during simulation
5f6d0c0d 2213 // \li rawfile=<i>file</i>
2214 // source for the RawReader to be created, the default is <i>./</i> if
2215 // raw data is simulated
cae21299 2216
2217 int iResult=0;
c4affb19 2218
2219 if (!fpHLT && !CreateHLT()) {
2220 return kFALSE;
2221 }
2222 AliHLTSimulation* pHLT=fpHLT;
2223
cae21299 2224 AliRunLoader* pRunLoader = LoadRun("READ");
2225 if (!pRunLoader) return kFALSE;
2226
795e4a22 2227 // initialize CDB storage, run number, set CDB lock
c4affb19 2228 // thats for the case of running HLT simulation without all the other steps
2229 // multiple calls are handled by the function, so we can just call
795e4a22 2230 InitCDB();
2231 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
2232 SetCDBLock();
2233
cae21299 2234 // init the HLT simulation
a441bf51 2235 TString options;
2236 if (fRunHLT.CompareTo("default")!=0) options=fRunHLT;
5f6d0c0d 2237 TString detStr = fWriteRawData;
2238 if (!IsSelected("HLT", detStr)) {
a441bf51 2239 options+=" writerawfiles=";
2240 } else {
2241 options+=" writerawfiles=HLT";
2242 }
5f6d0c0d 2243
2244 if (!detStr.IsNull() && !options.Contains("rawfile=")) {
2245 // as a matter of fact, HLT will run reconstruction and needs the RawReader
2246 // in order to get detector data. By default, RawReaderFile is used to read
2247 // the already simulated ddl files. Date and Root files from the raw data
2248 // are generated after the HLT simulation.
2249 options+=" rawfile=./";
2250 }
2251
cae21299 2252 AliHLTSimulationInit_t fctInit=(AliHLTSimulationInit_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_INIT));
a441bf51 2253 if (fctInit==NULL || (iResult=(fctInit(pHLT, pRunLoader, options.Data())))<0) {
cae21299 2254 AliError(Form("can not init HLT simulation: error %d (init %p)", iResult, fctInit));
2255 } else {
2256 // run the HLT simulation
2257 AliHLTSimulationRun_t fctRun=(AliHLTSimulationRun_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_RUN));
2258 if (fctRun==NULL || (iResult=(fctRun(pHLT, pRunLoader)))<0) {
2259 AliError(Form("can not run HLT simulation: error %d (run %p)", iResult, fctRun));
2260 }
2261 }
2262
2263 // delete the instance
2264 AliHLTSimulationDeleteInstance_t fctDelete=(AliHLTSimulationDeleteInstance_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_DELETE_INSTANCE));
2265 if (fctDelete==NULL || fctDelete(pHLT)<0) {
2266 AliError(Form("can not delete instance of HLT simulation (creator %p)", fctDelete));
2267 }
2268 pHLT=NULL;
2269
2270 return iResult>=0?kTRUE:kFALSE;
2271}
cae17938 2272
2273//_____________________________________________________________________________
a1b90a73 2274Bool_t AliSimulation::RunQA()
cae17938 2275{
a1b90a73 2276 // run the QA on summable hits, digits or digits
940d8e5f 2277
3ce48293 2278 //if(!gAlice) return kFALSE;
eca4fa66 2279 AliQAManager::QAManager()->SetRunLoader(AliRunLoader::Instance()) ;
a1b90a73 2280
e5dedfe2 2281 TString detectorsw("") ;
2282 Bool_t rv = kTRUE ;
eca4fa66 2283 AliQAManager::QAManager()->SetEventSpecie(fEventSpecie) ;
2284 detectorsw = AliQAManager::QAManager()->Run(fQADetectors.Data()) ;
e5dedfe2 2285 if ( detectorsw.IsNull() )
2286 rv = kFALSE ;
a1b90a73 2287 return rv ;
cae17938 2288}
2289
795e4a22 2290//_____________________________________________________________________________
e3b20d9a 2291Bool_t AliSimulation::SetRunQA(TString detAndAction)
2292{
2293 // Allows to run QA for a selected set of detectors
2294 // and a selected set of tasks among HITS, SDIGITS and DIGITS
2295 // all selected detectors run the same selected tasks
2296
2297 if (!detAndAction.Contains(":")) {
2298 AliError( Form("%s is a wrong syntax, use \"DetectorList:ActionList\" \n", detAndAction.Data()) ) ;
2299 fRunQA = kFALSE ;
2300 return kFALSE ;
2301 }
2302 Int_t colon = detAndAction.Index(":") ;
2303 fQADetectors = detAndAction(0, colon) ;
c54a46e3 2304 if (fQADetectors.Contains("ALL") ){
2305 TString tmp = Form("%s %s", fMakeDigits.Data(), fMakeDigitsFromHits.Data()) ;
2306 Int_t minus = fQADetectors.Last('-') ;
2307 TString toKeep = Form("%s %s", fMakeDigits.Data(), fMakeDigitsFromHits.Data()) ;
2308 TString toRemove("") ;
2309 while (minus >= 0) {
2310 toRemove = fQADetectors(minus+1, fQADetectors.Length()) ;
2311 toRemove = toRemove.Strip() ;
2312 toKeep.ReplaceAll(toRemove, "") ;
2313 fQADetectors.ReplaceAll(Form("-%s", toRemove.Data()), "") ;
2314 minus = fQADetectors.Last('-') ;
2315 }
2316 fQADetectors = toKeep ;
2317 }
2318 fQATasks = detAndAction(colon+1, detAndAction.Sizeof() ) ;
e3b20d9a 2319 if (fQATasks.Contains("ALL") ) {
4e25ac79 2320 fQATasks = Form("%d %d %d", AliQAv1::kHITS, AliQAv1::kSDIGITS, AliQAv1::kDIGITS) ;
e3b20d9a 2321 } else {
2322 fQATasks.ToUpper() ;
2323 TString tempo("") ;
2324 if ( fQATasks.Contains("HIT") )
4e25ac79 2325 tempo = Form("%d ", AliQAv1::kHITS) ;
e3b20d9a 2326 if ( fQATasks.Contains("SDIGIT") )
4e25ac79 2327 tempo += Form("%d ", AliQAv1::kSDIGITS) ;
e3b20d9a 2328 if ( fQATasks.Contains("DIGIT") )
4e25ac79 2329 tempo += Form("%d ", AliQAv1::kDIGITS) ;
e3b20d9a 2330 fQATasks = tempo ;
2331 if (fQATasks.IsNull()) {
2332 AliInfo("No QA requested\n") ;
2333 fRunQA = kFALSE ;
2334 return kTRUE ;
2335 }
2336 }
2337 TString tempo(fQATasks) ;
4e25ac79 2338 tempo.ReplaceAll(Form("%d", AliQAv1::kHITS), AliQAv1::GetTaskName(AliQAv1::kHITS)) ;
2339 tempo.ReplaceAll(Form("%d", AliQAv1::kSDIGITS), AliQAv1::GetTaskName(AliQAv1::kSDIGITS)) ;
2340 tempo.ReplaceAll(Form("%d", AliQAv1::kDIGITS), AliQAv1::GetTaskName(AliQAv1::kDIGITS)) ;
e3b20d9a 2341 AliInfo( Form("QA will be done on \"%s\" for \"%s\"\n", fQADetectors.Data(), tempo.Data()) ) ;
2342 fRunQA = kTRUE ;
eca4fa66 2343 AliQAManager::QAManager()->SetActiveDetectors(fQADetectors) ;
2344 AliQAManager::QAManager()->SetTasks(fQATasks) ;
4e25ac79 2345 for (Int_t det = 0 ; det < AliQAv1::kNDET ; det++)
eca4fa66 2346 AliQAManager::QAManager()->SetWriteExpert(AliQAv1::DETECTORINDEX_t(det)) ;
57acd2d2 2347
e3b20d9a 2348 return kTRUE;
2349}
2350
2351//_____________________________________________________________________________
795e4a22 2352void AliSimulation::ProcessEnvironmentVars()
2353{
2354// Extract run number and random generator seed from env variables
2355
2356 AliInfo("Processing environment variables");
2357
2358 // Random Number seed
2359
2360 // first check that seed is not already set
2361 if (fSeed == 0) {
2362 if (gSystem->Getenv("CONFIG_SEED")) {
2363 fSeed = atoi(gSystem->Getenv("CONFIG_SEED"));
2364 }
2365 } else {
2366 if (gSystem->Getenv("CONFIG_SEED")) {
2367 AliInfo(Form("Seed for random number generation already set (%d)"
2368 ": CONFIG_SEED variable ignored!", fSeed));
2369 }
2370 }
2371
2372 AliInfo(Form("Seed for random number generation = %d ", fSeed));
2373
2374 // Run Number
2375
2376 // first check that run number is not already set
2377 if(fRun < 0) {
2378 if (gSystem->Getenv("DC_RUN")) {
2379 fRun = atoi(gSystem->Getenv("DC_RUN"));
2380 }
2381 } else {
2382 if (gSystem->Getenv("DC_RUN")) {
2383 AliInfo(Form("Run number already set (%d): DC_RUN variable ignored!", fRun));
2384 }
2385 }
2386
2387 AliInfo(Form("Run number = %d", fRun));
2388}
ff5970a3 2389
44e45fac 2390//---------------------------------------------------------------------
fc7e1b1c 2391void AliSimulation::WriteGRPEntry()
2392{
2393 // Get the necessary information from galice (generator, trigger etc) and
2394 // write a GRP entry corresponding to the settings in the Config.C used
44e45fac 2395 // note that Hall probes and Cavern and Surface Atmos pressures are not simulated.
2396
2397
fc7e1b1c 2398 AliInfo("Writing global run parameters entry into the OCDB");
2399
44e45fac 2400 AliGRPObject* grpObj = new AliGRPObject();
fc7e1b1c 2401
44e45fac 2402 grpObj->SetRunType("PHYSICS");
475baf89 2403 grpObj->SetTimeStart(fTimeStart);
2404 grpObj->SetTimeEnd(fTimeEnd);
5cf76849 2405 grpObj->SetBeamEnergyIsSqrtSHalfGeV(); // new format of GRP: store sqrt(s)/2 in GeV
fc7e1b1c 2406
3e2e3ece 2407 const AliGenerator *gen = gAlice->GetMCApp()->Generator();
4dcef377 2408 Int_t a = 0;
2409 Int_t z = 0;
2410
fc7e1b1c 2411 if (gen) {
fc7e1b1c 2412 TString projectile;
fc7e1b1c 2413 gen->GetProjectile(projectile,a,z);
2414 TString target;
2415 gen->GetTarget(target,a,z);
2416 TString beamType = projectile + "-" + target;
214a2a31 2417 beamType.ReplaceAll(" ","");
e7c989e4 2418 if (!beamType.CompareTo("-")) {
57acd2d2 2419 grpObj->SetBeamType("UNKNOWN");
4dcef377 2420 grpObj->SetBeamEnergy(gen->GetEnergyCMS()/2);
e7c989e4 2421 }
2422 else {
57acd2d2 2423 grpObj->SetBeamType(beamType);
4dcef377 2424 if (z != 0) {
2425 grpObj->SetBeamEnergy(gen->GetEnergyCMS()/2 * a / z);
2426 } else {
2427 grpObj->SetBeamEnergy(gen->GetEnergyCMS()/2 );
2428 }
57acd2d2 2429 // Heavy ion run, the event specie is set to kHighMult
2430 fEventSpecie = AliRecoParam::kHighMult;
2431 if ((strcmp(beamType,"p-p") == 0) ||
2432 (strcmp(beamType,"p-") == 0) ||
2433 (strcmp(beamType,"-p") == 0) ||
2434 (strcmp(beamType,"P-P") == 0) ||
2435 (strcmp(beamType,"P-") == 0) ||
2436 (strcmp(beamType,"-P") == 0)) {
2437 // Proton run, the event specie is set to kLowMult
2438 fEventSpecie = AliRecoParam::kLowMult;
2439 }
e7c989e4 2440 }
57acd2d2 2441 } else {
44e45fac 2442 AliWarning("Unknown beam type and energy! Setting energy to 0");
2443 grpObj->SetBeamEnergy(0);
2444 grpObj->SetBeamType("UNKNOWN");
fc7e1b1c 2445 }
2446
2447 UInt_t detectorPattern = 0;
2448 Int_t nDets = 0;
2449 TObjArray *detArray = gAlice->Detectors();
2450 for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors-1; iDet++) {
2451 if (detArray->FindObject(AliDAQ::OfflineModuleName(iDet))) {
820b4d9e 2452 AliDebug(1, Form("Detector #%d found: %s", iDet, AliDAQ::OfflineModuleName(iDet)));
fc7e1b1c 2453 detectorPattern |= (1 << iDet);
2454 nDets++;
2455 }
2456 }
1be29b9e 2457 // CTP
28da60d3 2458 if (!fTriggerConfig.IsNull())
1be29b9e 2459 detectorPattern |= (1 << AliDAQ::DetectorID("TRG"));
2460
fc7e1b1c 2461 // HLT
2462 if (!fRunHLT.IsNull())
2463 detectorPattern |= (1 << AliDAQ::kHLTId);
ff5970a3 2464
44e45fac 2465 grpObj->SetNumberOfDetectors((Char_t)nDets);
2466 grpObj->SetDetectorMask((Int_t)detectorPattern);
2467 grpObj->SetLHCPeriod("LHC08c");
2468 grpObj->SetLHCState("STABLE_BEAMS");
99c7d495 2469 //
f7a1cc68 2470 AliMagF *field = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
2471 Float_t solenoidField = field ? TMath::Abs(field->SolenoidField()) : 0;
fc7e1b1c 2472
99c7d495 2473 Float_t factorSol = field ? field->GetFactorSol() : 0;
2474 Float_t currentSol = TMath::Abs(factorSol)>1E-6 ?
2475 TMath::Nint(TMath::Abs(solenoidField/factorSol))/5.*30000.*TMath::Abs(factorSol) : 0;
2476 //
2477 Float_t factorDip = field ? field->GetFactorDip() : 0;
2478 Float_t currentDip = 6000.*TMath::Abs(factorDip);
2479 //
2480 grpObj->SetL3Current(currentSol,(AliGRPObject::Stats)0);
2481 grpObj->SetDipoleCurrent(currentDip,(AliGRPObject::Stats)0);
2482 grpObj->SetL3Polarity(factorSol>0 ? 0:1);
2483 grpObj->SetDipolePolarity(factorDip>0 ? 0:1);
58c338d2 2484 if (field) grpObj->SetUniformBMap(field->IsUniform()); // for special MC with k5kGUniform map
99c7d495 2485 grpObj->SetPolarityConventionLHC(); // LHC convention +/+ current -> -/- field main components
2486 //
44e45fac 2487 grpObj->SetCavernTemperature(0,(AliGRPObject::Stats)0);
2488
2489 //grpMap->Add(new TObjString("fCavernPressure"),new TObjString("0")); ---> not inserted in simulation with the new object, since it is now an AliDCSSensor
fc7e1b1c 2490
2491 // Now store the entry in OCDB
2492 AliCDBManager* man = AliCDBManager::Instance();
732ee20f 2493
2494 man->SetLock(0, fKey);
2495
2496 AliCDBStorage* sto = man->GetStorage(fGRPWriteLocation.Data());
2497
fc7e1b1c 2498
2b541cc7 2499 AliCDBId id("GRP/GRP/Data", man->GetRun(), man->GetRun(), 1, 1);
fc7e1b1c 2500 AliCDBMetaData *metadata= new AliCDBMetaData();
2501
fc7e1b1c 2502 metadata->SetResponsible("alice-off@cern.ch");
2503 metadata->SetComment("Automatically produced GRP entry for Monte Carlo");
2504
732ee20f 2505 sto->Put(grpObj,id,metadata);
2506 man->SetLock(1, fKey);
fc7e1b1c 2507}
44e45fac 2508
475baf89 2509//_____________________________________________________________________________
2510time_t AliSimulation::GenerateTimeStamp() const
2511{
2512 // Generate event time-stamp according to
2513 // SOR/EOR time from GRP
2514 if (fUseTimeStampFromCDB)
2515 return fTimeStart + gRandom->Integer(fTimeEnd-fTimeStart);
2516 else
2517 return 0;
2518}
8e940b8f 2519
2520//_____________________________________________________________________________
2521void AliSimulation::StoreUsedCDBMaps() const
2522{
2523 // write in galice.root maps with used CDB paths
2524 //
2525 const TMap *cdbMap = AliCDBManager::Instance()->GetStorageMap();
2526 const TList *cdbList = AliCDBManager::Instance()->GetRetrievedIds();
2527 //
2528 TMap *cdbMapCopy = new TMap(cdbMap->GetEntries());
2529 cdbMapCopy->SetOwner(1);
2530 // cdbMapCopy->SetName("cdbMap");
2531 TIter iter(cdbMap->GetTable());
2532 //
2533 TPair* pair = 0;
2534 while((pair = dynamic_cast<TPair*> (iter.Next()))){
2535 TObjString* keyStr = dynamic_cast<TObjString*> (pair->Key());
2536 TObjString* valStr = dynamic_cast<TObjString*> (pair->Value());
2537 if (keyStr && valStr)
2538 cdbMapCopy->Add(new TObjString(keyStr->GetName()), new TObjString(valStr->GetName()));
2539 }
2540 //
2541 TList *cdbListCopy = new TList();
2542 cdbListCopy->SetOwner(1);
2543 // cdbListCopy->SetName("cdbList");
2544 //
2545 TIter iter2(cdbList);
2546
2547 AliCDBId* id=0;
2548 while((id = dynamic_cast<AliCDBId*> (iter2.Next()))){
2549 cdbListCopy->Add(new TObjString(id->ToString().Data()));
2550 }
2551 //
2552 AliRunLoader::Instance()->CdGAFile();
2553 gDirectory->WriteObject(cdbMapCopy,"cdbMap","kSingleKey");
2554 gDirectory->WriteObject(cdbListCopy,"cdbList","kSingleKey");
2555 //
2556 AliInfo(Form("Stored used OCDB entries as TMap %s and TList %s in %s",
2557 cdbMapCopy->GetName(),
2558 cdbListCopy->GetName(),
2559 fGAliceFileName.Data()));
2560 //
2561}