Option for kine only simulation added.
[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
16/* $Id$ */
17
18///////////////////////////////////////////////////////////////////////////////
19// //
20// class for running generation, simulation and digitization //
21// //
22// Hits, sdigits and digits are created for all detectors by typing: //
23// //
24// AliSimulation sim; //
25// sim.Run(); //
26// //
27// The Run method returns kTRUE in case of successful execution. //
28// The number of events can be given as argument to the Run method or it //
29// can be set by //
30// //
31// sim.SetNumberOfEvents(n); //
32// //
95601147 33// The name of the configuration file can be passed as argument to the //
34// AliSimulation constructor or can be specified by //
85a5290f 35// //
36// sim.SetConfigFile("..."); //
37// //
38// The generation of particles and the simulation of detector hits can be //
39// switched on or off by //
40// //
41// sim.SetRunGeneration(kTRUE); // generation of primary particles //
42// sim.SetRunSimulation(kFALSE); // but no tracking //
43// //
44// For which detectors sdigits and digits will be created, can be steered //
45// by //
46// //
47// sim.SetMakeSDigits("ALL"); // make sdigits for all detectors //
48// sim.SetMakeDigits("ITS TPC"); // make digits only for ITS and TPC //
49// //
50// The argument is a (case sensitive) string with the names of the //
51// detectors separated by a space. An empty string ("") can be used to //
52// disable the creation of sdigits or digits. The special string "ALL" //
53// selects all available detectors. This is the default. //
54// //
55// The creation of digits from hits instead of from sdigits can be selected //
56// by //
57// //
58// sim.SetMakeDigitsFromHits("TRD"); //
59// //
60// The argument is again a string with the selected detectors. Be aware that //
61// this feature is not available for all detectors and that merging is not //
62// possible, when digits are created directly from hits. //
63// //
05526d44 64// Background events can be merged by calling //
85a5290f 65// //
66// sim.MergeWith("background/galice.root", 2); //
67// //
68// The first argument is the file name of the background galice file. The //
69// second argument is the number of signal events per background event. //
05526d44 70// By default this number is calculated from the number of available //
71// background events. MergeWith can be called several times to merge more //
72// than two event streams. It is assumed that the sdigits were already //
73// produced for the background events. //
85a5290f 74// //
0421c3d1 75// The output of raw data can be switched on by calling //
76// //
77// sim.SetWriteRawData("MUON"); // write raw data for MUON //
78// //
06c7e392 79// The default output format of the raw data are DDL files. They are //
80// converted to a DATE file, if a file name is given as second argument. //
81// For this conversion the program "dateStream" is required. If the file //
82// name has the extension ".root", the DATE file is converted to a root //
83// file. The program "alimdc" is used for this purpose. For the conversion //
84// to DATE and root format the two conversion programs have to be installed. //
85// Only the raw data in the final format is kept if the third argument is //
86// kTRUE. //
87// //
0421c3d1 88// The methods RunSimulation, RunSDigitization, RunDigitization, //
89// RunHitsDigitization and WriteRawData can be used to run only parts of //
06c7e392 90// the full simulation chain. The creation of raw data DDL files and their //
91// conversion to the DATE or root format can be run directly by calling //
92// the methods WriteRawFiles, ConvertRawFilesToDate and ConvertDateToRoot. //
95601147 93// //
18b43626 94// The default number of events per file, which is usually set in the //
95// config file, can be changed for individual detectors and data types //
96// by calling //
97// //
98// sim.SetEventsPerFile("PHOS", "Reconstructed Points", 3); //
99// //
100// The first argument is the detector, the second one the data type and the //
101// last one the number of events per file. Valid data types are "Hits", //
102// "Summable Digits", "Digits", "Reconstructed Points" and "Tracks". //
103// The number of events per file has to be set before the simulation of //
104// hits. Otherwise it has no effect. //
105// //
85a5290f 106///////////////////////////////////////////////////////////////////////////////
107
3e2e3ece 108#include <TCint.h>
109#include <TFile.h>
f7a1cc68 110#include <TGeoGlobalMagField.h>
e8d02863 111#include <TGeoManager.h>
85a5290f 112#include <TObjString.h>
fc7e1b1c 113#include <TROOT.h>
3e2e3ece 114#include <TSystem.h>
115#include <TVirtualMC.h>
116#include <TVirtualMCApplication.h>
5cf76849 117#include <TDatime.h>
252fff8d 118#include <TInterpreter.h>
85a5290f 119
3e2e3ece 120#include "AliAlignObj.h"
e8d02863 121#include "AliCDBEntry.h"
122#include "AliCDBManager.h"
732ee20f 123#include "AliGRPManager.h"
3e2e3ece 124#include "AliCDBStorage.h"
125#include "AliCTPRawData.h"
126#include "AliCentralTrigger.h"
e8d02863 127#include "AliCentralTrigger.h"
3e2e3ece 128#include "AliCodeTimer.h"
362c9d61 129#include "AliDAQ.h"
af7ba10c 130#include "AliDigitizer.h"
6d985680 131#include "AliESDEvent.h"
3e2e3ece 132#include "AliGRPObject.h"
133#include "AliGenEventHeader.h"
af7ba10c 134#include "AliGenerator.h"
3e2e3ece 135#include "AliGeomManager.h"
136#include "AliHLTSimulation.h"
137#include "AliHeader.h"
f7a1cc68 138#include "AliLego.h"
139#include "AliLegoGenerator.h"
e8d02863 140#include "AliLog.h"
3e2e3ece 141#include "AliMC.h"
142#include "AliMagF.h"
af7ba10c 143#include "AliModule.h"
3e2e3ece 144#include "AliPDG.h"
145#include "AliRawReaderDate.h"
146#include "AliRawReaderFile.h"
147#include "AliRawReaderRoot.h"
af7ba10c 148#include "AliRun.h"
f21fc003 149#include "AliDigitizationInput.h"
af7ba10c 150#include "AliRunLoader.h"
35ec1f70 151#include "AliStack.h"
af7ba10c 152#include "AliSimulation.h"
27fc67fa 153#include "AliSysInfo.h"
3e2e3ece 154#include "AliVertexGenFile.h"
85a5290f 155
66b0310c 156using std::ofstream;
85a5290f 157ClassImp(AliSimulation)
158
b856a511 159AliSimulation *AliSimulation::fgInstance = 0;
820b4d9e 160const char* AliSimulation::fgkDetectorName[AliSimulation::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE"
161// #ifdef MFT_UPGRADE
162// ,"MFT"
163// #endif
164 ,"MFT" // AU
165 ,"HLT"
166};
85a5290f 167
168//_____________________________________________________________________________
795e4a22 169AliSimulation::AliSimulation(const char* configFileName,
95601147 170 const char* name, const char* title) :
171 TNamed(name, title),
172
35ec1f70 173 fRunGeneratorOnly(kFALSE),
95601147 174 fRunGeneration(kTRUE),
175 fRunSimulation(kTRUE),
024cf675 176 fLoadAlignFromCDB(kTRUE),
25be1e5c 177 fLoadAlObjsListOfDets("ALL"),
95601147 178 fMakeSDigits("ALL"),
179 fMakeDigits("ALL"),
28da60d3 180 fTriggerConfig(""),
95601147 181 fMakeDigitsFromHits(""),
0421c3d1 182 fWriteRawData(""),
06c7e392 183 fRawDataFileName(""),
184 fDeleteIntermediateFiles(kFALSE),
67327b72 185 fWriteSelRawData(kFALSE),
95601147 186 fStopOnError(kFALSE),
a5fe2c41 187 fUseMonitoring(kFALSE),
95601147 188 fNEvents(1),
189 fConfigFileName(configFileName),
190 fGAliceFileName("galice.root"),
18b43626 191 fEventsPerFile(),
95601147 192 fBkgrdFileNames(NULL),
995ad051 193 fAlignObjArray(NULL),
04bae0a0 194 fUseBkgrdVertex(kTRUE),
024cf675 195 fRegionOfInterest(kFALSE),
795e4a22 196 fCDBUri(""),
f1c1204d 197 fQARefUri(""),
ca30848f 198 fSpecCDBUri(),
795e4a22 199 fRun(-1),
200 fSeed(0),
201 fInitCDBCalled(kFALSE),
202 fInitRunNumberCalled(kFALSE),
203 fSetRunNumberFromDataCalled(kFALSE),
cae21299 204 fEmbeddingFlag(kFALSE),
3e2e3ece 205 fLego(NULL),
732ee20f 206 fKey(0),
207 fUseVertexFromCDB(0),
208 fUseMagFieldFromGRP(0),
209 fGRPWriteLocation(Form("local://%s", gSystem->pwd())),
475baf89 210 fUseTimeStampFromCDB(0),
211 fTimeStart(0),
212 fTimeEnd(0),
e3b20d9a 213 fQADetectors("ALL"),
214 fQATasks("ALL"),
759c1df1 215 fRunQA(kTRUE),
57acd2d2 216 fEventSpecie(AliRecoParam::kDefault),
75373542 217 fWriteQAExpertData(kTRUE),
1b1f5ae6 218 fGeometryFile(),
fc7e1b1c 219 fRunHLT("default"),
c4affb19 220 fpHLT(NULL),
fc7e1b1c 221 fWriteGRPEntry(kTRUE)
85a5290f 222{
223// create simulation object with default parameters
b856a511 224 fgInstance = this;
0421c3d1 225 SetGAliceFile("galice.root");
5b188f2f 226
227// for QA
634696f5 228 AliQAManager * qam = AliQAManager::QAManager(AliQAv1::kSIMMODE) ;
eca4fa66 229 qam->SetActiveDetectors(fQADetectors) ;
4e25ac79 230 fQATasks = Form("%d %d %d", AliQAv1::kHITS, AliQAv1::kSDIGITS, AliQAv1::kDIGITS) ;
eca4fa66 231 qam->SetTasks(fQATasks) ;
85a5290f 232}
233
85a5290f 234//_____________________________________________________________________________
235AliSimulation::~AliSimulation()
236{
237// clean up
238
18b43626 239 fEventsPerFile.Delete();
024cf675 240// if(fAlignObjArray) fAlignObjArray->Delete(); // fAlignObjArray->RemoveAll() ???
241// delete fAlignObjArray; fAlignObjArray=0;
18b43626 242
95601147 243 if (fBkgrdFileNames) {
244 fBkgrdFileNames->Delete();
245 delete fBkgrdFileNames;
246 }
ec92bee0 247
248 fSpecCDBUri.Delete();
b856a511 249 if (fgInstance==this) fgInstance = 0;
87932dab 250
bf76b847 251 AliQAManager::QAManager()->ShowQA() ;
252 AliQAManager::Destroy() ;
87932dab 253 AliCodeTimer::Instance()->Print();
85a5290f 254}
255
256
257//_____________________________________________________________________________
258void AliSimulation::SetNumberOfEvents(Int_t nEvents)
259{
260// set the number of events for one run
261
262 fNEvents = nEvents;
263}
264
f1c1204d 265//_____________________________________________________________________________
266void AliSimulation::InitQA()
267{
268 // activate a default CDB storage
269 // First check if we have any CDB storage set, because it is used
270 // to retrieve the calibration and alignment constants
271
272 if (fInitCDBCalled) return;
273 fInitCDBCalled = kTRUE;
274
634696f5 275 AliQAManager * qam = AliQAManager::QAManager(AliQAv1::kSIMMODE) ;
eca4fa66 276 qam->SetActiveDetectors(fQADetectors) ;
4e25ac79 277 fQATasks = Form("%d %d %d", AliQAv1::kHITS, AliQAv1::kSDIGITS, AliQAv1::kDIGITS) ;
eca4fa66 278 qam->SetTasks(fQATasks) ;
75373542 279 if (fWriteQAExpertData)
eca4fa66 280 qam->SetWriteExpert() ;
f1c1204d 281
eca4fa66 282 if (qam->IsDefaultStorageSet()) {
f1c1204d 283 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
284 AliWarning("Default QA reference storage has been already set !");
285 AliWarning(Form("Ignoring the default storage declared in AliSimulation: %s",fQARefUri.Data()));
286 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
eca4fa66 287 fQARefUri = qam->GetDefaultStorage()->GetURI();
f1c1204d 288 } else {
289 if (fQARefUri.Length() > 0) {
290 AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
291 AliDebug(2, Form("Default QA reference storage is set to: %s", fQARefUri.Data()));
292 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
293 } else {
294 fQARefUri="local://$ALICE_ROOT/QARef";
295 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
296 AliWarning("Default QA reference storage not yet set !!!!");
297 AliWarning(Form("Setting it now to: %s", fQARefUri.Data()));
298 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
299 }
eca4fa66 300 qam->SetDefaultStorage(fQARefUri);
f1c1204d 301 }
302}
303
024cf675 304//_____________________________________________________________________________
795e4a22 305void AliSimulation::InitCDB()
024cf675 306{
307// activate a default CDB storage
308// First check if we have any CDB storage set, because it is used
309// to retrieve the calibration and alignment constants
310
795e4a22 311 if (fInitCDBCalled) return;
312 fInitCDBCalled = kTRUE;
313
024cf675 314 AliCDBManager* man = AliCDBManager::Instance();
ec92bee0 315 if (man->IsDefaultStorageSet())
024cf675 316 {
ec92bee0 317 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
318 AliWarning("Default CDB storage has been already set !");
ced249e6 319 AliWarning(Form("Ignoring the default storage declared in AliSimulation: %s",fCDBUri.Data()));
ec92bee0 320 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
795e4a22 321 fCDBUri = man->GetDefaultStorage()->GetURI();
ec92bee0 322 }
323 else {
795e4a22 324 if (fCDBUri.Length() > 0)
325 {
326 AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
327 AliDebug(2, Form("Default CDB storage is set to: %s", fCDBUri.Data()));
328 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
329 } else {
162637e4 330 fCDBUri="local://$ALICE_ROOT/OCDB";
795e4a22 331 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
332 AliWarning("Default CDB storage not yet set !!!!");
333 AliWarning(Form("Setting it now to: %s", fCDBUri.Data()));
334 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
335
336 }
ec92bee0 337 man->SetDefaultStorage(fCDBUri);
338 }
339
340 // Now activate the detector specific CDB storage locations
341 for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
342 TObject* obj = fSpecCDBUri[i];
343 if (!obj) continue;
b8ec52f6 344 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
345 AliDebug(2, Form("Specific CDB storage for %s is set to: %s",obj->GetName(),obj->GetTitle()));
346 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
c3a7b59a 347 man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
ec92bee0 348 }
795e4a22 349
024cf675 350}
351
352//_____________________________________________________________________________
795e4a22 353void AliSimulation::InitRunNumber(){
354// check run number. If not set, set it to 0 !!!!
355
356 if (fInitRunNumberCalled) return;
357 fInitRunNumberCalled = kTRUE;
358
359 AliCDBManager* man = AliCDBManager::Instance();
360 if (man->GetRun() >= 0)
361 {
8c8fbdcd 362 AliFatal(Form("Run number cannot be set in AliCDBManager before start of simulation: "
363 "Use external variable DC_RUN or AliSimulation::SetRun()!"));
795e4a22 364 }
8c8fbdcd 365
366 if(fRun >= 0) {
795e4a22 367 AliDebug(2, Form("Setting CDB run number to: %d",fRun));
8c8fbdcd 368 } else {
795e4a22 369 fRun=0;
76c8e8d6 370 AliWarning(Form("Run number not yet set !!!! Setting it now to: %d",
371 fRun));
795e4a22 372 }
8c8fbdcd 373 man->SetRun(fRun);
024cf675 374
795e4a22 375 man->Print();
024cf675 376
377}
378
00aa02d5 379//_____________________________________________________________________________
795e4a22 380void AliSimulation::SetCDBLock() {
381 // Set CDB lock: from now on it is forbidden to reset the run number
382 // or the default storage or to activate any further storage!
383
6fc2efbf 384 ULong64_t key = AliCDBManager::Instance()->SetLock(1);
732ee20f 385 if (key) fKey = key;
795e4a22 386}
387
388//_____________________________________________________________________________
389void AliSimulation::SetDefaultStorage(const char* uri) {
f1c1204d 390 // Store the desired default CDB storage location
391 // Activate it later within the Run() method
392
795e4a22 393 fCDBUri = uri;
f1c1204d 394
395}
00aa02d5 396
f1c1204d 397//_____________________________________________________________________________
398void AliSimulation::SetQARefDefaultStorage(const char* uri) {
399 // Store the desired default CDB storage location
400 // Activate it later within the Run() method
401
402 fQARefUri = uri;
4e25ac79 403 AliQAv1::SetQARefStorage(fQARefUri.Data()) ;
00aa02d5 404}
405
024cf675 406//_____________________________________________________________________________
c3a7b59a 407void AliSimulation::SetSpecificStorage(const char* calibType, const char* uri) {
ec92bee0 408// Store a detector-specific CDB storage location
409// Activate it later within the Run() method
024cf675 410
c3a7b59a 411 AliCDBPath aPath(calibType);
412 if(!aPath.IsValid()){
413 AliError(Form("Not a valid path: %s", calibType));
414 return;
415 }
416
417 TObject* obj = fSpecCDBUri.FindObject(calibType);
ec92bee0 418 if (obj) fSpecCDBUri.Remove(obj);
c3a7b59a 419 fSpecCDBUri.Add(new TNamed(calibType, uri));
024cf675 420
421}
422
795e4a22 423//_____________________________________________________________________________
424void AliSimulation::SetRunNumber(Int_t run)
425{
426// sets run number
427// Activate it later within the Run() method
428
429 fRun = run;
430}
431
432//_____________________________________________________________________________
433void AliSimulation::SetSeed(Int_t seed)
434{
435// sets seed number
436// Activate it later within the Run() method
437
438 fSeed = seed;
439}
440
441//_____________________________________________________________________________
442Bool_t AliSimulation::SetRunNumberFromData()
443{
444 // Set the CDB manager run number
445 // The run number is retrieved from gAlice
446
447 if (fSetRunNumberFromDataCalled) return kTRUE;
448 fSetRunNumberFromDataCalled = kTRUE;
449
450 AliCDBManager* man = AliCDBManager::Instance();
451 Int_t runData = -1, runCDB = -1;
452
453 AliRunLoader* runLoader = LoadRun("READ");
454 if (!runLoader) return kFALSE;
455 else {
d3b3a3b2 456 runData = runLoader->GetHeader()->GetRun();
795e4a22 457 delete runLoader;
458 }
459
460 runCDB = man->GetRun();
461 if(runCDB >= 0) {
462 if (runCDB != runData) {
463 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
464 AliWarning(Form("A run number was previously set in AliCDBManager: %d !", runCDB));
465 AliWarning(Form("It will be replaced with the run number got from run header: %d !", runData));
466 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
467 }
468
469 }
470
471 man->SetRun(runData);
472 fRun = runData;
473
474 if(man->GetRun() < 0) {
475 AliError("Run number not properly initalized!");
476 return kFALSE;
477 }
478
479 man->Print();
480
481 return kTRUE;
482}
483
85a5290f 484//_____________________________________________________________________________
485void AliSimulation::SetConfigFile(const char* fileName)
486{
487// set the name of the config file
488
489 fConfigFileName = fileName;
490}
491
0421c3d1 492//_____________________________________________________________________________
493void AliSimulation::SetGAliceFile(const char* fileName)
494{
495// set the name of the galice file
496// the path is converted to an absolute one if it is relative
497
498 fGAliceFileName = fileName;
499 if (!gSystem->IsAbsoluteFileName(fGAliceFileName)) {
500 char* absFileName = gSystem->ConcatFileName(gSystem->WorkingDirectory(),
501 fGAliceFileName);
502 fGAliceFileName = absFileName;
503 delete[] absFileName;
504 }
ac1671c0 505
506 AliDebug(2, Form("galice file name set to %s", fileName));
0421c3d1 507}
508
18b43626 509//_____________________________________________________________________________
510void AliSimulation::SetEventsPerFile(const char* detector, const char* type,
511 Int_t nEvents)
512{
513// set the number of events per file for the given detector and data type
514// ("Hits", "Summable Digits", "Digits", "Reconstructed Points" or "Tracks")
515
516 TNamed* obj = new TNamed(detector, type);
517 obj->SetUniqueID(nEvents);
518 fEventsPerFile.Add(obj);
519}
520
6bae477a 521//_____________________________________________________________________________
522Bool_t AliSimulation::MisalignGeometry(AliRunLoader *runLoader)
523{
524 // Read the alignment objects from CDB.
525 // Each detector is supposed to have the
526 // alignment objects in DET/Align/Data CDB path.
527 // All the detector objects are then collected,
528 // sorted by geometry level (starting from ALIC) and
529 // then applied to the TGeo geometry.
530 // Finally an overlaps check is performed.
531
74ae4297 532 if (!AliGeomManager::GetGeometry() || !AliGeomManager::GetGeometry()->IsClosed()) {
533 AliError("Can't apply the misalignment! Geometry is not loaded or it is still opened!");
0717eed2 534 return kFALSE;
535 }
795e4a22 536
537 // initialize CDB storage, run number, set CDB lock
538 InitCDB();
539// if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
540 SetCDBLock();
541
6bae477a 542 Bool_t delRunLoader = kFALSE;
543 if (!runLoader) {
544 runLoader = LoadRun("READ");
545 if (!runLoader) return kFALSE;
546 delRunLoader = kTRUE;
547 }
795e4a22 548
b856a511 549 // Export ideal geometry
d97f1dbe 550 if(!IsGeometryFromFile()) AliGeomManager::GetGeometry()->Export("geometry.root");
b856a511 551
25be1e5c 552 // Load alignment data from CDB and apply to geometry through AliGeomManager
6bae477a 553 if(fLoadAlignFromCDB){
25be1e5c 554
555 TString detStr = fLoadAlObjsListOfDets;
556 TString loadAlObjsListOfDets = "";
557
558 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
559 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
560 AliModule* det = (AliModule*) detArray->At(iDet);
561 if (!det || !det->IsActive()) continue;
562 if (IsSelected(det->GetName(), detStr)) {
0717eed2 563 //add det to list of dets to be aligned from CDB
564 loadAlObjsListOfDets += det->GetName();
565 loadAlObjsListOfDets += " ";
25be1e5c 566 }
567 } // end loop over detectors
53dd3c3d 568 loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
45daac75 569 AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
25be1e5c 570 }else{
571 // Check if the array with alignment objects was
572 // provided by the user. If yes, apply the objects
573 // to the present TGeo geometry
574 if (fAlignObjArray) {
45daac75 575 if (AliGeomManager::ApplyAlignObjsToGeom(*fAlignObjArray) == kFALSE) {
0717eed2 576 AliError("The misalignment of one or more volumes failed!"
577 "Compare the list of simulated detectors and the list of detector alignment data!");
578 if (delRunLoader) delete runLoader;
579 return kFALSE;
6bae477a 580 }
581 }
6bae477a 582 }
583
ef7ff1f9 584 // Update the internal geometry of modules (ITS needs it)
25be1e5c 585 TString detStr = fLoadAlObjsListOfDets;
ef7ff1f9 586 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
587 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
588
589 AliModule* det = (AliModule*) detArray->At(iDet);
590 if (!det || !det->IsActive()) continue;
591 if (IsSelected(det->GetName(), detStr)) {
592 det->UpdateInternalGeometry();
593 }
594 } // end loop over detectors
595
596
6bae477a 597 if (delRunLoader) delete runLoader;
598
599 return kTRUE;
600}
601
85a5290f 602//_____________________________________________________________________________
603void AliSimulation::MergeWith(const char* fileName, Int_t nSignalPerBkgrd)
604{
605// add a file with background events for merging
606
607 TObjString* fileNameStr = new TObjString(fileName);
608 fileNameStr->SetUniqueID(nSignalPerBkgrd);
95601147 609 if (!fBkgrdFileNames) fBkgrdFileNames = new TObjArray;
85a5290f 610 fBkgrdFileNames->Add(fileNameStr);
611}
612
ca30848f 613void AliSimulation::EmbedInto(const char* fileName, Int_t nSignalPerBkgrd)
614{
615// add a file with background events for embeddin
616 MergeWith(fileName, nSignalPerBkgrd);
617 fEmbeddingFlag = kTRUE;
618}
85a5290f 619
620//_____________________________________________________________________________
621Bool_t AliSimulation::Run(Int_t nEvents)
622{
623// run the generation, simulation and digitization
624
c65c502a 625
99c136e1 626 AliCodeTimerAuto("",0)
6fcf567c 627 AliSysInfo::AddStamp("Start_Run");
87932dab 628
795e4a22 629 // Load run number and seed from environmental vars
630 ProcessEnvironmentVars();
6fcf567c 631 AliSysInfo::AddStamp("ProcessEnvironmentVars");
b0314964 632
795e4a22 633 gRandom->SetSeed(fSeed);
634
85a5290f 635 if (nEvents > 0) fNEvents = nEvents;
636
35ec1f70 637 // Run generator-only code on demand
638 if (fRunGeneratorOnly)
639 {
640 if(!RunGeneratorOnly())
641 {
642 if (fStopOnError) return kFALSE;
643 }
644 else
645 return kTRUE;
646 }
647
c4affb19 648 // create and setup the HLT instance
649 if (!fRunHLT.IsNull() && !CreateHLT()) {
650 if (fStopOnError) return kFALSE;
651 // disable HLT
652 fRunHLT="";
653 }
c516e34c 654
85a5290f 655 // generation and simulation -> hits
656 if (fRunGeneration) {
85a5290f 657 if (!RunSimulation()) if (fStopOnError) return kFALSE;
658 }
6fcf567c 659 AliSysInfo::AddStamp("RunSimulation");
795e4a22 660
661 // initialize CDB storage from external environment
662 // (either CDB manager or AliSimulation setters),
663 // if not already done in RunSimulation()
664 InitCDB();
6fcf567c 665 AliSysInfo::AddStamp("InitCDB");
795e4a22 666
667 // Set run number in CDBManager from data
668 // From this point on the run number must be always loaded from data!
669 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
670
671 // Set CDB lock: from now on it is forbidden to reset the run number
672 // or the default storage or to activate any further storage!
673 SetCDBLock();
6bae477a 674
25be1e5c 675 // If RunSimulation was not called, load the geometry and misalign it
74ae4297 676 if (!AliGeomManager::GetGeometry()) {
677 // Initialize the geometry manager
1b1f5ae6 678 AliGeomManager::LoadGeometry("geometry.root");
2eab8cf7 679 AliSysInfo::AddStamp("GetGeometry");
ff5970a3 680// // Check that the consistency of symbolic names for the activated subdetectors
681// // in the geometry loaded by AliGeomManager
682// AliRunLoader* runLoader = LoadRun("READ");
683// if (!runLoader) return kFALSE;
684//
685// TString detsToBeChecked = "";
686// TObjArray* detArray = runLoader->GetAliRun()->Detectors();
687// for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
688// AliModule* det = (AliModule*) detArray->At(iDet);
689// if (!det || !det->IsActive()) continue;
690// detsToBeChecked += det->GetName();
691// detsToBeChecked += " ";
692// } // end loop over detectors
693// if(!AliGeomManager::CheckSymNamesLUT(detsToBeChecked.Data()))
694 if(!AliGeomManager::CheckSymNamesLUT("ALL"))
0bf7aade 695 AliFatalClass("Current loaded geometry differs in the definition of symbolic names!");
ff5970a3 696
74ae4297 697 if (!AliGeomManager::GetGeometry()) if (fStopOnError) return kFALSE;
698 // Misalign geometry
25be1e5c 699 if(!MisalignGeometry()) if (fStopOnError) return kFALSE;
6bae477a 700 }
6fcf567c 701 AliSysInfo::AddStamp("MissalignGeometry");
25be1e5c 702
27fc67fa 703
85a5290f 704 // hits -> summable digits
27fc67fa 705 AliSysInfo::AddStamp("Start_sdigitization");
85a5290f 706 if (!fMakeSDigits.IsNull()) {
707 if (!RunSDigitization(fMakeSDigits)) if (fStopOnError) return kFALSE;
a1b90a73 708
85a5290f 709 }
27fc67fa 710 AliSysInfo::AddStamp("Stop_sdigitization");
c65c502a 711
27fc67fa 712 AliSysInfo::AddStamp("Start_digitization");
795e4a22 713 // summable digits -> digits
85a5290f 714 if (!fMakeDigits.IsNull()) {
715 if (!RunDigitization(fMakeDigits, fMakeDigitsFromHits)) {
716 if (fStopOnError) return kFALSE;
717 }
a1b90a73 718 }
27fc67fa 719 AliSysInfo::AddStamp("Stop_digitization");
85a5290f 720
795e4a22 721
722
85a5290f 723 // hits -> digits
724 if (!fMakeDigitsFromHits.IsNull()) {
95601147 725 if (fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
ac1671c0 726 AliWarning(Form("Merging and direct creation of digits from hits "
727 "was selected for some detectors. "
728 "No merging will be done for the following detectors: %s",
729 fMakeDigitsFromHits.Data()));
85a5290f 730 }
731 if (!RunHitsDigitization(fMakeDigitsFromHits)) {
732 if (fStopOnError) return kFALSE;
733 }
734 }
735
6fcf567c 736 AliSysInfo::AddStamp("Hits2Digits");
795e4a22 737
738
a5a091ce 739 // digits -> trigger
4471cf15 740 if (!fTriggerConfig.IsNull() && !RunTrigger(fTriggerConfig,fMakeDigits)) {
087426de 741 if (fStopOnError) return kFALSE;
a5a091ce 742 }
743
6fcf567c 744 AliSysInfo::AddStamp("RunTrigger");
795e4a22 745
746
0421c3d1 747 // digits -> raw data
748 if (!fWriteRawData.IsNull()) {
06c7e392 749 if (!WriteRawData(fWriteRawData, fRawDataFileName,
67327b72 750 fDeleteIntermediateFiles,fWriteSelRawData)) {
0421c3d1 751 if (fStopOnError) return kFALSE;
752 }
753 }
754
6fcf567c 755 AliSysInfo::AddStamp("WriteRaw");
795e4a22 756
5f6d0c0d 757 // run HLT simulation on simulated digit data if raw data is not
758 // simulated, otherwise its called as part of WriteRawData
759 if (!fRunHLT.IsNull() && fWriteRawData.IsNull()) {
cae21299 760 if (!RunHLT()) {
761 if (fStopOnError) return kFALSE;
762 }
763 }
6fcf567c 764
765 AliSysInfo::AddStamp("RunHLT");
795e4a22 766
04236e67 767 //QA
f5cb4aec 768 if (fRunQA) {
769 Bool_t rv = RunQA() ;
770 if (!rv)
771 if (fStopOnError)
772 return kFALSE ;
773 }
795e4a22 774
6fcf567c 775 AliSysInfo::AddStamp("RunQA");
776
989744a6 777 TString snapshotFileOut("");
f5cb4aec 778 if(TString(gSystem->Getenv("OCDB_SNAPSHOT_CREATE")) == TString("kTRUE")){
779 AliInfo(" ******** Creating the snapshot! *********");
780 TString snapshotFile(gSystem->Getenv("OCDB_SNAPSHOT_FILENAME"));
781 if(!(snapshotFile.IsNull() || snapshotFile.IsWhitespace()))
782 snapshotFileOut = snapshotFile;
783 else
784 snapshotFileOut="OCDB.root";
c022b397 785 AliCDBManager::Instance()->DumpToSnapshotFile(snapshotFileOut.Data(),kFALSE);
f5cb4aec 786 }
787
795e4a22 788 // Cleanup of CDB manager: cache and active storages!
789 AliCDBManager::Instance()->ClearCache();
790
85a5290f 791 return kTRUE;
792}
793
3e2e3ece 794//_______________________________________________________________________
795Bool_t AliSimulation::RunLego(const char *setup, Int_t nc1, Float_t c1min,
796 Float_t c1max,Int_t nc2,Float_t c2min,Float_t c2max,
797 Float_t rmin,Float_t rmax,Float_t zmax, AliLegoGenerator* gener, Int_t nev)
798{
799 //
800 // Generates lego plots of:
801 // - radiation length map phi vs theta
802 // - radiation length map phi vs eta
803 // - interaction length map
804 // - g/cm2 length map
805 //
806 // ntheta bins in theta, eta
807 // themin minimum angle in theta (degrees)
808 // themax maximum angle in theta (degrees)
809 // nphi bins in phi
810 // phimin minimum angle in phi (degrees)
811 // phimax maximum angle in phi (degrees)
812 // rmin minimum radius
813 // rmax maximum radius
814 //
815 //
816 // The number of events generated = ntheta*nphi
817 // run input parameters in macro setup (default="Config.C")
818 //
819 // Use macro "lego.C" to visualize the 3 lego plots in spherical coordinates
820 //Begin_Html
821 /*
822 <img src="picts/AliRunLego1.gif">
823 */
824 //End_Html
825 //Begin_Html
826 /*
827 <img src="picts/AliRunLego2.gif">
828 */
829 //End_Html
830 //Begin_Html
831 /*
832 <img src="picts/AliRunLego3.gif">
833 */
834 //End_Html
835 //
836
837// run the generation and simulation
838
99c136e1 839 AliCodeTimerAuto("",0)
3e2e3ece 840
841 // initialize CDB storage and run number from external environment
842 // (either CDB manager or AliSimulation setters)
843 InitCDB();
844 InitRunNumber();
845 SetCDBLock();
846
847 if (!gAlice) {
848 AliError("no gAlice object. Restart aliroot and try again.");
849 return kFALSE;
850 }
851 if (gAlice->Modules()->GetEntries() > 0) {
852 AliError("gAlice was already run. Restart aliroot and try again.");
853 return kFALSE;
854 }
855
856 AliInfo(Form("initializing gAlice with config file %s",
857 fConfigFileName.Data()));
858
859 // Number of events
860 if (nev == -1) nev = nc1 * nc2;
861
862 // check if initialisation has been done
863 // If runloader has been initialized, set the number of events per file to nc1 * nc2
864
865 // Set new generator
866 if (!gener) gener = new AliLegoGenerator();
867 //
868 // Configure Generator
869
870 gener->SetRadiusRange(rmin, rmax);
871 gener->SetZMax(zmax);
872 gener->SetCoor1Range(nc1, c1min, c1max);
873 gener->SetCoor2Range(nc2, c2min, c2max);
874
875
876 //Create Lego object
877 fLego = new AliLego("lego",gener);
878
879 //__________________________________________________________________________
880
881 gAlice->Announce();
882
883 gROOT->LoadMacro(setup);
884 gInterpreter->ProcessLine(gAlice->GetConfigFunction());
885
886 if(AliCDBManager::Instance()->GetRun() >= 0) {
887 SetRunNumber(AliCDBManager::Instance()->GetRun());
888 } else {
889 AliWarning("Run number not initialized!!");
890 }
f7a1cc68 891
33c3c91a 892 AliRunLoader::Instance()->CdGAFile();
3e2e3ece 893
894 AliPDG::AddParticlesToPdgDataBase();
895
f7a1cc68 896 gMC->SetMagField(TGeoGlobalMagField::Instance()->GetField());
897
55338a9a 898 gAlice->GetMCApp()->Init();
899
f7a1cc68 900
3e2e3ece 901 //Must be here because some MCs (G4) adds detectors here and not in Config.C
902 gAlice->InitLoaders();
33c3c91a 903 AliRunLoader::Instance()->MakeTree("E");
3e2e3ece 904
905 //
906 // Save stuff at the beginning of the file to avoid file corruption
33c3c91a 907 AliRunLoader::Instance()->CdGAFile();
3e2e3ece 908 gAlice->Write();
909
910 //Save current generator
911 AliGenerator *gen=gAlice->GetMCApp()->Generator();
912 gAlice->GetMCApp()->ResetGenerator(gener);
913 //Prepare MC for Lego Run
914 gMC->InitLego();
915
916 //Run Lego Object
917
918
33c3c91a 919 AliRunLoader::Instance()->SetNumberOfEventsPerFile(nev);
3e2e3ece 920 gMC->ProcessRun(nev);
921
922 // End of this run, close files
923 FinishRun();
924 // Restore current generator
925 gAlice->GetMCApp()->ResetGenerator(gen);
926 // Delete Lego Object
927 delete fLego;
928
929 return kTRUE;
930}
931
a5a091ce 932//_____________________________________________________________________________
8480396b 933Bool_t AliSimulation::RunTrigger(const char* config, const char* detectors)
a5a091ce 934{
935 // run the trigger
936
99c136e1 937 AliCodeTimerAuto("",0)
a5a091ce 938
795e4a22 939 // initialize CDB storage from external environment
940 // (either CDB manager or AliSimulation setters),
941 // if not already done in RunSimulation()
942 InitCDB();
943
944 // Set run number in CDBManager from data
945 // From this point on the run number must be always loaded from data!
946 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
947
948 // Set CDB lock: from now on it is forbidden to reset the run number
949 // or the default storage or to activate any further storage!
950 SetCDBLock();
951
bacbe0fd 952 AliRunLoader* runLoader = LoadRun("READ");
953 if (!runLoader) return kFALSE;
51f6d619 954 TString trconfiguration = config;
bacbe0fd 955
51f6d619 956 if (trconfiguration.IsNull()) {
28da60d3 957 if(!fTriggerConfig.IsNull()) {
958 trconfiguration = fTriggerConfig;
087426de 959 }
51f6d619 960 else
8480396b 961 AliWarning("No trigger descriptor is specified. Loading the one that is in the CDB.");
087426de 962 }
963
0f46f5fa 964 runLoader->MakeTree( "GG" );
bacbe0fd 965 AliCentralTrigger* aCTP = runLoader->GetTrigger();
51f6d619 966 // Load Configuration
967 if (!aCTP->LoadConfiguration( trconfiguration ))
968 return kFALSE;
a5a091ce 969
51f6d619 970 // digits -> trigger
8480396b 971 if( !aCTP->RunTrigger( runLoader , detectors ) ) {
a5a091ce 972 if (fStopOnError) {
51f6d619 973 // delete aCTP;
974 return kFALSE;
a5a091ce 975 }
bacbe0fd 976 }
a5a091ce 977
bacbe0fd 978 delete runLoader;
a5a091ce 979
bacbe0fd 980 return kTRUE;
a5a091ce 981}
982
007155cc 983//_____________________________________________________________________________
984Bool_t AliSimulation::WriteTriggerRawData()
985{
986 // Writes the CTP (trigger) DDL raw data
987 // Details of the format are given in the
988 // trigger TDR - pages 134 and 135.
989 AliCTPRawData writer;
990 writer.RawData();
a5a091ce 991
007155cc 992 return kTRUE;
993}
a5a091ce 994
85a5290f 995//_____________________________________________________________________________
95601147 996Bool_t AliSimulation::RunSimulation(Int_t nEvents)
85a5290f 997{
998// run the generation and simulation
999
99c136e1 1000 AliCodeTimerAuto("",0)
4df28b43 1001
795e4a22 1002 // initialize CDB storage and run number from external environment
1003 // (either CDB manager or AliSimulation setters)
6fcf567c 1004 AliSysInfo::AddStamp("RunSimulation_Begin");
795e4a22 1005 InitCDB();
6fcf567c 1006 AliSysInfo::AddStamp("RunSimulation_InitCDB");
795e4a22 1007 InitRunNumber();
f5cb4aec 1008
795e4a22 1009 SetCDBLock();
6fcf567c 1010 AliSysInfo::AddStamp("RunSimulation_SetCDBLock");
795e4a22 1011
95601147 1012 if (!gAlice) {
ac1671c0 1013 AliError("no gAlice object. Restart aliroot and try again.");
95601147 1014 return kFALSE;
1015 }
1016 if (gAlice->Modules()->GetEntries() > 0) {
ac1671c0 1017 AliError("gAlice was already run. Restart aliroot and try again.");
95601147 1018 return kFALSE;
1019 }
a5fe2c41 1020
1021 // Setup monitoring if requested
1022 gAlice->GetMCApp()->SetUseMonitoring(fUseMonitoring);
95601147 1023
ac1671c0 1024 AliInfo(Form("initializing gAlice with config file %s",
1025 fConfigFileName.Data()));
3e2e3ece 1026
1027 //
1028 // Initialize ALICE Simulation run
1029 //
3e2e3ece 1030 gAlice->Announce();
1031
732ee20f 1032 //
1033 // If requested set the mag. field from the GRP entry.
1034 // After this the field is loccked and cannot be changed by Config.C
1035 if (fUseMagFieldFromGRP) {
1036 AliGRPManager grpM;
1037 grpM.ReadGRPEntry();
1038 grpM.SetMagField();
1039 AliInfo("Field is locked now. It cannot be changed in Config.C");
1040 }
1041//
1042// Execute Config.C
252fff8d 1043 TInterpreter::EErrorCode interpreterError=TInterpreter::kNoError;
3e2e3ece 1044 gROOT->LoadMacro(fConfigFileName.Data());
252fff8d 1045 Long_t interpreterResult=gInterpreter->ProcessLine(gAlice->GetConfigFunction(), &interpreterError);
1046 if (interpreterResult!=0 || interpreterError!=TInterpreter::kNoError) {
1047 AliFatal(Form("execution of config file \"%s\" failed with error %d", fConfigFileName.Data(), (int)interpreterError));
1048 }
6fcf567c 1049 AliSysInfo::AddStamp("RunSimulation_Config");
3e2e3ece 1050
732ee20f 1051//
1052// If requested obtain the vertex position and vertex sigma_z from the CDB
1053// This overwrites the settings from the Config.C
1054 if (fUseVertexFromCDB) {
1055 Double_t vtxPos[3] = {0., 0., 0.};
1056 Double_t vtxSig[3] = {0., 0., 0.};
b71fc657 1057 AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
58c338d2 1058 if (entry) {
1059 AliESDVertex* vertex = dynamic_cast<AliESDVertex*> (entry->GetObject());
1060 if (vertex) {
1061 if(vertex->GetXRes()>2.8) { // > pipe radius --> it's a dummy object, don't use it
1062 entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexSPD");
c134270c 1063 if (entry) vertex = dynamic_cast<AliESDVertex*> (entry->GetObject());
58c338d2 1064 }
1065 }
1066 if (vertex) {
1067 vertex->GetXYZ(vtxPos);
1068 vertex->GetSigmaXYZ(vtxSig);
1069 AliInfo("Overwriting Config.C vertex settings !");
1070 AliInfo(Form("Vertex position from OCDB entry: x = %13.3f, y = %13.3f, z = %13.3f (sigma = %13.3f)\n",
1071 vtxPos[0], vtxPos[1], vtxPos[2], vtxSig[2]));
1072
1073 AliGenerator *gen = gAlice->GetMCApp()->Generator();
1074 gen->SetOrigin(vtxPos[0], vtxPos[1], vtxPos[2]); // vertex position
1075 gen->SetSigmaZ(vtxSig[2]);
766f0285 1076 }
732ee20f 1077 }
1078 }
475baf89 1079
1080 // If requested we take the SOR and EOR time-stamps from the GRP and use them
1081 // in order to generate the event time-stamps
1082 if (fUseTimeStampFromCDB) {
1083 AliGRPManager grpM;
1084 grpM.ReadGRPEntry();
1085 const AliGRPObject *grpObj = grpM.GetGRPData();
1086 if (!grpObj || (grpObj->GetTimeEnd() <= grpObj->GetTimeStart())) {
1087 AliError("Missing GRP or bad SOR/EOR time-stamps! Switching off the time-stamp generation from GRP!");
1088 fTimeStart = fTimeEnd = 0;
1089 fUseTimeStampFromCDB = kFALSE;
1090 }
1091 else {
1092 fTimeStart = grpObj->GetTimeStart();
1093 fTimeEnd = grpObj->GetTimeEnd();
1094 }
1095 }
732ee20f 1096
3e2e3ece 1097 if(AliCDBManager::Instance()->GetRun() >= 0) {
33c3c91a 1098 AliRunLoader::Instance()->SetRunNumber(AliCDBManager::Instance()->GetRun());
c516e34c 1099 AliRunLoader::Instance()->SetNumberOfEventsPerRun(fNEvents);
3e2e3ece 1100 } else {
1101 AliWarning("Run number not initialized!!");
1102 }
1103
33c3c91a 1104 AliRunLoader::Instance()->CdGAFile();
732ee20f 1105
1106
3e2e3ece 1107 AliPDG::AddParticlesToPdgDataBase();
1108
f7a1cc68 1109 gMC->SetMagField(TGeoGlobalMagField::Instance()->GetField());
6fcf567c 1110 AliSysInfo::AddStamp("RunSimulation_GetField");
55338a9a 1111 gAlice->GetMCApp()->Init();
1112 AliSysInfo::AddStamp("RunSimulation_InitMCApp");
1113
3e2e3ece 1114 //Must be here because some MCs (G4) adds detectors here and not in Config.C
1115 gAlice->InitLoaders();
33c3c91a 1116 AliRunLoader::Instance()->MakeTree("E");
1117 AliRunLoader::Instance()->LoadKinematics("RECREATE");
1118 AliRunLoader::Instance()->LoadTrackRefs("RECREATE");
1119 AliRunLoader::Instance()->LoadHits("all","RECREATE");
3e2e3ece 1120 //
1121 // Save stuff at the beginning of the file to avoid file corruption
33c3c91a 1122 AliRunLoader::Instance()->CdGAFile();
3e2e3ece 1123 gAlice->Write();
1124 gAlice->SetEventNrInRun(-1); //important - we start Begin event from increasing current number in run
6fcf567c 1125 AliSysInfo::AddStamp("RunSimulation_InitLoaders");
3e2e3ece 1126 //___________________________________________________________________________________________
795e4a22 1127
6fcf567c 1128 AliSysInfo::AddStamp("RunSimulation_TriggerDescriptor");
087426de 1129
6bae477a 1130 // Set run number in CDBManager
024cf675 1131 AliInfo(Form("Run number: %d",AliCDBManager::Instance()->GetRun()));
1132
33c3c91a 1133 AliRunLoader* runLoader = AliRunLoader::Instance();
024cf675 1134 if (!runLoader) {
1135 AliError(Form("gAlice has no run loader object. "
1136 "Check your config file: %s", fConfigFileName.Data()));
1137 return kFALSE;
1138 }
1139 SetGAliceFile(runLoader->GetFileName());
795e4a22 1140
6bae477a 1141 // Misalign geometry
caf9c464 1142#if ROOT_VERSION_CODE < 331527
74ae4297 1143 AliGeomManager::SetGeometry(gGeoManager);
ff5970a3 1144
1145 // Check that the consistency of symbolic names for the activated subdetectors
1146 // in the geometry loaded by AliGeomManager
1147 TString detsToBeChecked = "";
1148 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1149 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1150 AliModule* det = (AliModule*) detArray->At(iDet);
1151 if (!det || !det->IsActive()) continue;
1152 detsToBeChecked += det->GetName();
1153 detsToBeChecked += " ";
1154 } // end loop over detectors
1155 if(!AliGeomManager::CheckSymNamesLUT(detsToBeChecked.Data()))
0bf7aade 1156 AliFatalClass("Current loaded geometry differs in the definition of symbolic names!");
caf9c464 1157 MisalignGeometry(runLoader);
6fcf567c 1158 AliSysInfo::AddStamp("RunSimulation_MisalignGeometry");
caf9c464 1159#endif
995ad051 1160
33c3c91a 1161// AliRunLoader* runLoader = AliRunLoader::Instance();
024cf675 1162// if (!runLoader) {
1163// AliError(Form("gAlice has no run loader object. "
1164// "Check your config file: %s", fConfigFileName.Data()));
1165// return kFALSE;
1166// }
1167// SetGAliceFile(runLoader->GetFileName());
85a5290f 1168
3e2e3ece 1169 if (!gAlice->GetMCApp()->Generator()) {
ac1671c0 1170 AliError(Form("gAlice has no generator object. "
1171 "Check your config file: %s", fConfigFileName.Data()));
04bae0a0 1172 return kFALSE;
1173 }
fc7e1b1c 1174
1175 // Write GRP entry corresponding to the setting found in Cofig.C
1176 if (fWriteGRPEntry)
1177 WriteGRPEntry();
6fcf567c 1178 AliSysInfo::AddStamp("RunSimulation_WriteGRP");
fc7e1b1c 1179
05526d44 1180 if (nEvents <= 0) nEvents = fNEvents;
04bae0a0 1181
1182 // get vertex from background file in case of merging
1183 if (fUseBkgrdVertex &&
1184 fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
05526d44 1185 Int_t signalPerBkgrd = GetNSignalPerBkgrd(nEvents);
04bae0a0 1186 const char* fileName = ((TObjString*)
1187 (fBkgrdFileNames->At(0)))->GetName();
ac1671c0 1188 AliInfo(Form("The vertex will be taken from the background "
1189 "file %s with nSignalPerBackground = %d",
1190 fileName, signalPerBkgrd));
04bae0a0 1191 AliVertexGenFile* vtxGen = new AliVertexGenFile(fileName, signalPerBkgrd);
3e2e3ece 1192 gAlice->GetMCApp()->Generator()->SetVertexGenerator(vtxGen);
04bae0a0 1193 }
1194
85a5290f 1195 if (!fRunSimulation) {
3e2e3ece 1196 gAlice->GetMCApp()->Generator()->SetTrackingFlag(0);
85a5290f 1197 }
1198
18b43626 1199 // set the number of events per file for given detectors and data types
1200 for (Int_t i = 0; i < fEventsPerFile.GetEntriesFast(); i++) {
1201 if (!fEventsPerFile[i]) continue;
1202 const char* detName = fEventsPerFile[i]->GetName();
1203 const char* typeName = fEventsPerFile[i]->GetTitle();
1204 TString loaderName(detName);
1205 loaderName += "Loader";
1206 AliLoader* loader = runLoader->GetLoader(loaderName);
1207 if (!loader) {
65b25288 1208 AliError(Form("RunSimulation no loader for %s found\n Number of events per file not set for %s %s",
ac1671c0 1209 detName, typeName, detName));
18b43626 1210 continue;
1211 }
1212 AliDataLoader* dataLoader =
1213 loader->GetDataLoader(typeName);
1214 if (!dataLoader) {
ac1671c0 1215 AliError(Form("no data loader for %s found\n"
1216 "Number of events per file not set for %s %s",
1217 typeName, detName, typeName));
18b43626 1218 continue;
1219 }
1220 dataLoader->SetNumberOfEventsPerFile(fEventsPerFile[i]->GetUniqueID());
ac1671c0 1221 AliDebug(1, Form("number of events per file set to %d for %s %s",
1222 fEventsPerFile[i]->GetUniqueID(), detName, typeName));
18b43626 1223 }
1224
ac1671c0 1225 AliInfo("running gAlice");
6fcf567c 1226 AliSysInfo::AddStamp("Start_ProcessRun");
124253ee 1227
124253ee 1228 // Create the Root Tree with one branch per detector
1229 //Hits moved to begin event -> now we are crating separate tree for each event
124253ee 1230 gMC->ProcessRun(nEvents);
1231
1232 // End of this run, close files
3e2e3ece 1233 if(nEvents>0) FinishRun();
124253ee 1234
6fcf567c 1235 AliSysInfo::AddStamp("Stop_ProcessRun");
95601147 1236 delete runLoader;
85a5290f 1237
1238 return kTRUE;
1239}
1240
35ec1f70 1241//_____________________________________________________________________________
1242Bool_t AliSimulation::RunGeneratorOnly()
1243{
1244 // Execute Config.C
1245 TInterpreter::EErrorCode interpreterError=TInterpreter::kNoError;
1246 gROOT->LoadMacro(fConfigFileName.Data());
1247 Long_t interpreterResult=gInterpreter->ProcessLine(gAlice->GetConfigFunction(), &interpreterError);
1248 if (interpreterResult!=0 || interpreterError!=TInterpreter::kNoError) {
1249 AliFatal(Form("execution of config file \"%s\" failed with error %d", fConfigFileName.Data(), (int)interpreterError));
1250 }
1251
1252 // Setup the runloader and generator, check if everything is OK
1253 AliRunLoader* runLoader = AliRunLoader::Instance();
1254 AliGenerator* generator = gAlice->GetMCApp()->Generator();
1255 if (!runLoader) {
1256 AliError(Form("gAlice has no run loader object. "
1257 "Check your config file: %s", fConfigFileName.Data()));
1258 return kFALSE;
1259 }
1260 if (!generator) {
1261 AliError(Form("gAlice has no generator object. "
1262 "Check your config file: %s", fConfigFileName.Data()));
1263 return kFALSE;
1264 }
1265
1266 runLoader->LoadKinematics("RECREATE");
1267 runLoader->MakeTree("E");
1268
1269 // Create stack and header
1270 runLoader->MakeStack();
1271 AliStack* stack = runLoader->Stack();
1272 AliHeader* header = runLoader->GetHeader();
1273
1274 // Intialize generator
1275 generator->Init();
1276 generator->SetStack(stack);
1277
1278 // Run main generator loop
1279
1280 for (Int_t iev=0; iev<fNEvents; iev++)
1281 {
1282 // Initialize event
1283 header->Reset(0,iev);
1284 runLoader->SetEventNumber(iev);
1285 stack->Reset();
1286 runLoader->MakeTree("K");
1287
1288 // Generate event
1289 generator->Generate();
1290
1291 // Finish event
1292 header->SetNprimary(stack->GetNprimary());
1293 header->SetNtrack(stack->GetNtrack());
1294 stack->FinishEvent();
1295 header->SetStack(stack);
1296 runLoader->TreeE()->Fill();
1297 runLoader->WriteKinematics("OVERWRITE");
1298 }
1299
1300 // Finalize
1301 generator->FinishRun();
1302 // Write file
1303 runLoader->WriteHeader("OVERWRITE");
1304 generator->Write();
1305 runLoader->Write();
1306}
1307
85a5290f 1308//_____________________________________________________________________________
95601147 1309Bool_t AliSimulation::RunSDigitization(const char* detectors)
85a5290f 1310{
1311// run the digitization and produce summable digits
27fc67fa 1312 static Int_t eventNr=0;
99c136e1 1313 AliCodeTimerAuto("",0) ;
4df28b43 1314
795e4a22 1315 // initialize CDB storage, run number, set CDB lock
1316 InitCDB();
1317 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
1318 SetCDBLock();
1319
95601147 1320 AliRunLoader* runLoader = LoadRun();
1321 if (!runLoader) return kFALSE;
1322
85a5290f 1323 TString detStr = detectors;
95601147 1324 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
85a5290f 1325 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1326 AliModule* det = (AliModule*) detArray->At(iDet);
1327 if (!det || !det->IsActive()) continue;
1328 if (IsSelected(det->GetName(), detStr)) {
ac1671c0 1329 AliInfo(Form("creating summable digits for %s", det->GetName()));
a899e40b 1330 AliCodeTimerStart(Form("creating summable digits for %s", det->GetName()));
85a5290f 1331 det->Hits2SDigits();
a899e40b 1332 AliCodeTimerStop(Form("creating summable digits for %s", det->GetName()));
27fc67fa 1333 AliSysInfo::AddStamp(Form("Digit_%s_%d",det->GetName(),eventNr), 0,1, eventNr);
85a5290f 1334 }
1335 }
1336
1337 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
ac1671c0 1338 AliError(Form("the following detectors were not found: %s",
1339 detStr.Data()));
85a5290f 1340 if (fStopOnError) return kFALSE;
1341 }
27fc67fa 1342 eventNr++;
95601147 1343 delete runLoader;
1344
85a5290f 1345 return kTRUE;
1346}
1347
1348
1349//_____________________________________________________________________________
95601147 1350Bool_t AliSimulation::RunDigitization(const char* detectors,
1351 const char* excludeDetectors)
85a5290f 1352{
1353// run the digitization and produce digits from sdigits
1354
99c136e1 1355 AliCodeTimerAuto("",0)
4df28b43 1356
795e4a22 1357 // initialize CDB storage, run number, set CDB lock
1358 InitCDB();
1359 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
1360 SetCDBLock();
1361
33c3c91a 1362 delete AliRunLoader::Instance();
124253ee 1363 delete gAlice;
95601147 1364 gAlice = NULL;
1365
1366 Int_t nStreams = 1;
05526d44 1367 if (fBkgrdFileNames) nStreams = fBkgrdFileNames->GetEntriesFast() + 1;
1368 Int_t signalPerBkgrd = GetNSignalPerBkgrd();
f21fc003 1369 AliDigitizationInput digInp(nStreams, signalPerBkgrd);
1370 // digInp.SetEmbeddingFlag(fEmbeddingFlag);
1371 digInp.SetRegionOfInterest(fRegionOfInterest);
1372 digInp.SetInputStream(0, fGAliceFileName.Data());
85a5290f 1373 for (Int_t iStream = 1; iStream < nStreams; iStream++) {
f21fc003 1374 const char* fileName = ((TObjString*)(fBkgrdFileNames->At(iStream-1)))->GetName();
1375 digInp.SetInputStream(iStream, fileName);
85a5290f 1376 }
f21fc003 1377 TObjArray detArr;
1378 detArr.SetOwner(kTRUE);
85a5290f 1379 TString detStr = detectors;
1380 TString detExcl = excludeDetectors;
f21fc003 1381 if (!static_cast<AliStream*>(digInp.GetInputStream(0))->ImportgAlice()) {
1382 AliError("Error occured while getting gAlice from Input 0");
1383 return kFALSE;
1384 }
1385 AliRunLoader* runLoader = AliRunLoader::GetRunLoader(digInp.GetInputStream(0)->GetFolderName());
95601147 1386 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
85a5290f 1387 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1388 AliModule* det = (AliModule*) detArray->At(iDet);
1389 if (!det || !det->IsActive()) continue;
f21fc003 1390 if (!IsSelected(det->GetName(), detStr) || IsSelected(det->GetName(), detExcl)) continue;
1391 AliDigitizer* digitizer = det->CreateDigitizer(&digInp);
1392 if (!digitizer || !digitizer->Init()) {
1393 AliError(Form("no digitizer for %s", det->GetName()));
1394 if (fStopOnError) return kFALSE;
1395 else continue;
85a5290f 1396 }
f21fc003 1397 detArr.AddLast(digitizer);
1398 AliInfo(Form("Created digitizer from SDigits -> Digits for %s", det->GetName()));
85a5290f 1399 }
f21fc003 1400 //
85a5290f 1401 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
f21fc003 1402 AliError(Form("the following detectors were not found: %s", detStr.Data()));
85a5290f 1403 if (fStopOnError) return kFALSE;
1404 }
f21fc003 1405 //
1406 Int_t ndigs = detArr.GetEntriesFast();
1407 Int_t eventsCreated = 0;
1408 AliRunLoader* outRl = digInp.GetOutRunLoader();
1409 while ((eventsCreated++ < fNEvents) || (fNEvents < 0)) {
1410 if (!digInp.ConnectInputTrees()) break;
1411 digInp.InitEvent(); //this must be after call of Connect Input tress.
1412 if (outRl) outRl->SetEventNumber(eventsCreated-1);
1413 static_cast<AliStream*>(digInp.GetInputStream(0))->ImportgAlice(); // use gAlice of the first input stream
1414 for (int id=0;id<ndigs;id++) ((AliDigitizer*)detArr[id])->Digitize("");
1415 digInp.FinishEvent();
1416 };
1417 digInp.FinishGlobal();
1418 //
85a5290f 1419 return kTRUE;
1420}
1421
1422//_____________________________________________________________________________
95601147 1423Bool_t AliSimulation::RunHitsDigitization(const char* detectors)
85a5290f 1424{
1425// run the digitization and produce digits from hits
1426
99c136e1 1427 AliCodeTimerAuto("",0)
4df28b43 1428
795e4a22 1429 // initialize CDB storage, run number, set CDB lock
1430 InitCDB();
1431 if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
1432 SetCDBLock();
1433
591f51bb 1434 AliRunLoader* runLoader = LoadRun("READ");
95601147 1435 if (!runLoader) return kFALSE;
1436
85a5290f 1437 TString detStr = detectors;
95601147 1438 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
85a5290f 1439 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1440 AliModule* det = (AliModule*) detArray->At(iDet);
1441 if (!det || !det->IsActive()) continue;
1442 if (IsSelected(det->GetName(), detStr)) {
ac1671c0 1443 AliInfo(Form("creating digits from hits for %s", det->GetName()));
85a5290f 1444 det->Hits2Digits();
1445 }
1446 }
1447
1448 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
ac1671c0 1449 AliError(Form("the following detectors were not found: %s",
1450 detStr.Data()));
85a5290f 1451 if (fStopOnError) return kFALSE;
1452 }
1453
1454 return kTRUE;
1455}
1456
0421c3d1 1457//_____________________________________________________________________________
06c7e392 1458Bool_t AliSimulation::WriteRawData(const char* detectors,
1459 const char* fileName,
67327b72 1460 Bool_t deleteIntermediateFiles,
1461 Bool_t selrawdata)
0421c3d1 1462{
1463// convert the digits to raw data
06c7e392 1464// First DDL raw data files for the given detectors are created.
1465// If a file name is given, the DDL files are then converted to a DATE file.
1466// If deleteIntermediateFiles is true, the DDL raw files are deleted
1467// afterwards.
1468// If the file name has the extension ".root", the DATE file is converted
1469// to a root file.
1470// If deleteIntermediateFiles is true, the DATE file is deleted afterwards.
67327b72 1471// 'selrawdata' flag can be used to enable writing of detectors raw data
1472// accoring to the trigger cluster.
0421c3d1 1473
99c136e1 1474 AliCodeTimerAuto("",0)
6fcf567c 1475 AliSysInfo::AddStamp("WriteRawData_Start");
4cce3e4e 1476
1477 TString detStr = detectors;
4cce3e4e 1478 if (!WriteRawFiles(detStr.Data())) {
06c7e392 1479 if (fStopOnError) return kFALSE;
1480 }
6fcf567c 1481 AliSysInfo::AddStamp("WriteRawFiles");
06c7e392 1482
5f6d0c0d 1483 // run HLT simulation on simulated DDL raw files
1484 // and produce HLT ddl raw files to be included in date/root file
c4affb19 1485 // bugfix 2009-06-26: the decision whether to write HLT raw data
1486 // is taken in RunHLT. Here HLT always needs to be run in order to
1487 // create HLT digits, unless its switched off. This is due to the
1488 // special placement of the HLT between the generation of DDL files
1489 // and conversion to DATE/Root file.
1490 detStr.ReplaceAll("HLT", "");
1491 if (!fRunHLT.IsNull()) {
5f6d0c0d 1492 if (!RunHLT()) {
1493 if (fStopOnError) return kFALSE;
1494 }
1495 }
6fcf567c 1496 AliSysInfo::AddStamp("WriteRawData_RunHLT");
5f6d0c0d 1497
06c7e392 1498 TString dateFileName(fileName);
1499 if (!dateFileName.IsNull()) {
1500 Bool_t rootOutput = dateFileName.EndsWith(".root");
1501 if (rootOutput) dateFileName += ".date";
67327b72 1502 TString selDateFileName;
1503 if (selrawdata) {
1504 selDateFileName = "selected.";
1505 selDateFileName+= dateFileName;
1506 }
1507 if (!ConvertRawFilesToDate(dateFileName,selDateFileName)) {
06c7e392 1508 if (fStopOnError) return kFALSE;
1509 }
6fcf567c 1510 AliSysInfo::AddStamp("ConvertRawFilesToDate");
06c7e392 1511 if (deleteIntermediateFiles) {
1512 AliRunLoader* runLoader = LoadRun("READ");
1513 if (runLoader) for (Int_t iEvent = 0;
1514 iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
1515 char command[256];
76880c9a 1516 snprintf(command, 256, "rm -r raw%d", iEvent);
06c7e392 1517 gSystem->Exec(command);
1518 }
a978141c 1519 delete runLoader;
06c7e392 1520 }
1521
1522 if (rootOutput) {
1523 if (!ConvertDateToRoot(dateFileName, fileName)) {
1524 if (fStopOnError) return kFALSE;
1525 }
6fcf567c 1526 AliSysInfo::AddStamp("ConvertDateToRoot");
06c7e392 1527 if (deleteIntermediateFiles) {
1528 gSystem->Unlink(dateFileName);
1529 }
67327b72 1530 if (selrawdata) {
1531 TString selFileName = "selected.";
1532 selFileName += fileName;
1533 if (!ConvertDateToRoot(selDateFileName, selFileName)) {
1534 if (fStopOnError) return kFALSE;
1535 }
1536 if (deleteIntermediateFiles) {
1537 gSystem->Unlink(selDateFileName);
1538 }
1539 }
06c7e392 1540 }
1541 }
1542
06c7e392 1543 return kTRUE;
1544}
1545
1546//_____________________________________________________________________________
1547Bool_t AliSimulation::WriteRawFiles(const char* detectors)
1548{
1549// convert the digits to raw data DDL files
1550
99c136e1 1551 AliCodeTimerAuto("",0)
87932dab 1552
06c7e392 1553 AliRunLoader* runLoader = LoadRun("READ");
0421c3d1 1554 if (!runLoader) return kFALSE;
1555
06c7e392 1556 // write raw data to DDL files
0421c3d1 1557 for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
ac1671c0 1558 AliInfo(Form("processing event %d", iEvent));
0421c3d1 1559 runLoader->GetEvent(iEvent);
1560 TString baseDir = gSystem->WorkingDirectory();
1561 char dirName[256];
76880c9a 1562 snprintf(dirName, 256, "raw%d", iEvent);
0421c3d1 1563 gSystem->MakeDirectory(dirName);
1564 if (!gSystem->ChangeDirectory(dirName)) {
ac1671c0 1565 AliError(Form("couldn't change to directory %s", dirName));
0421c3d1 1566 if (fStopOnError) return kFALSE; else continue;
1567 }
1568
3fbd60fe 1569 ofstream runNbFile(Form("run%u",runLoader->GetHeader()->GetRun()));
1570 runNbFile.close();
1571
0421c3d1 1572 TString detStr = detectors;
5f6d0c0d 1573 if (IsSelected("HLT", detStr)) {
1574 // Do nothing. "HLT" will be removed from detStr and HLT raw
1575 // data files are generated in RunHLT.
1576 }
1577
0421c3d1 1578 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1579 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1580 AliModule* det = (AliModule*) detArray->At(iDet);
1581 if (!det || !det->IsActive()) continue;
1582 if (IsSelected(det->GetName(), detStr)) {
ac1671c0 1583 AliInfo(Form("creating raw data from digits for %s", det->GetName()));
0421c3d1 1584 det->Digits2Raw();
1585 }
1586 }
1587
007155cc 1588 if (!WriteTriggerRawData())
1589 if (fStopOnError) return kFALSE;
1590
0421c3d1 1591 gSystem->ChangeDirectory(baseDir);
1592 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
ac1671c0 1593 AliError(Form("the following detectors were not found: %s",
1594 detStr.Data()));
0421c3d1 1595 if (fStopOnError) return kFALSE;
1596 }
1597 }
1598
1599 delete runLoader;
87932dab 1600
06c7e392 1601 return kTRUE;
1602}
0421c3d1 1603
06c7e392 1604//_____________________________________________________________________________
67327b72 1605Bool_t AliSimulation::ConvertRawFilesToDate(const char* dateFileName,
1606 const char* selDateFileName)
06c7e392 1607{
1608// convert raw data DDL files to a DATE file with the program "dateStream"
67327b72 1609// The second argument is not empty when the user decides to write
1610// the detectors raw data according to the trigger cluster.
06c7e392 1611
99c136e1 1612 AliCodeTimerAuto("",0)
87932dab 1613
06c7e392 1614 char* path = gSystem->Which(gSystem->Getenv("PATH"), "dateStream");
1615 if (!path) {
ac1671c0 1616 AliError("the program dateStream was not found");
06c7e392 1617 if (fStopOnError) return kFALSE;
1618 } else {
1619 delete[] path;
1620 }
0421c3d1 1621
06c7e392 1622 AliRunLoader* runLoader = LoadRun("READ");
1623 if (!runLoader) return kFALSE;
1624
ac1671c0 1625 AliInfo(Form("converting raw data DDL files to DATE file %s", dateFileName));
67327b72 1626 Bool_t selrawdata = kFALSE;
1627 if (strcmp(selDateFileName,"") != 0) selrawdata = kTRUE;
1628
06c7e392 1629 char command[256];
f28a8d2d 1630 // Note the option -s. It is used in order to avoid
1631 // the generation of SOR/EOR events.
76880c9a 1632 snprintf(command, 256, "dateStream -c -s -D -o %s -# %d -C -run %d",
5c0fd670 1633 dateFileName, runLoader->GetNumberOfEvents(),runLoader->GetHeader()->GetRun());
06c7e392 1634 FILE* pipe = gSystem->OpenPipe(command, "w");
1635
f5e7d9d8 1636 if (!pipe) {
1637 AliError(Form("Cannot execute command: %s",command));
1638 return kFALSE;
1639 }
1640
67327b72 1641 Int_t selEvents = 0;
06c7e392 1642 for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
06c7e392 1643
f59c50c6 1644 UInt_t detectorPattern = 0;
1645 runLoader->GetEvent(iEvent);
1646 if (!runLoader->LoadTrigger()) {
1647 AliCentralTrigger *aCTP = runLoader->GetTrigger();
1648 detectorPattern = aCTP->GetClusterMask();
67327b72 1649 // Check if the event was triggered by CTP
f59c50c6 1650 if (selrawdata) {
67327b72 1651 if (aCTP->GetClassMask()) selEvents++;
1652 }
f59c50c6 1653 }
1654 else {
1655 AliWarning("No trigger can be loaded! Some fields in the event header will be empty !");
1656 if (selrawdata) {
67327b72 1657 AliWarning("No trigger can be loaded! Writing of selected raw data is abandoned !");
1658 selrawdata = kFALSE;
1659 }
1660 }
1661
dcf4b43a 1662 fprintf(pipe, "GDC DetectorPattern %u Timestamp %ld\n", detectorPattern, runLoader->GetHeader()->GetTimeStamp());
f59c50c6 1663 Float_t ldc = 0;
1664 Int_t prevLDC = -1;
1665
06c7e392 1666 // loop over detectors and DDLs
362c9d61 1667 for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
1668 for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls(iDet); iDDL++) {
06c7e392 1669
362c9d61 1670 Int_t ddlID = AliDAQ::DdlID(iDet,iDDL);
06c7e392 1671 Int_t ldcID = Int_t(ldc + 0.0001);
362c9d61 1672 ldc += AliDAQ::NumberOfLdcs(iDet) / AliDAQ::NumberOfDdls(iDet);
06c7e392 1673
1674 char rawFileName[256];
76880c9a 1675 snprintf(rawFileName, 256, "raw%d/%s",
362c9d61 1676 iEvent, AliDAQ::DdlFileName(iDet,iDDL));
06c7e392 1677
1678 // check existence and size of raw data file
1679 FILE* file = fopen(rawFileName, "rb");
1680 if (!file) continue;
1681 fseek(file, 0, SEEK_END);
1682 unsigned long size = ftell(file);
aa04f81b 1683 fclose(file);
1684 if (!size) continue;
06c7e392 1685
1686 if (ldcID != prevLDC) {
1687 fprintf(pipe, " LDC Id %d\n", ldcID);
1688 prevLDC = ldcID;
1689 }
1690 fprintf(pipe, " Equipment Id %d Payload %s\n", ddlID, rawFileName);
1691 }
1692 }
1693 }
1694
1695 Int_t result = gSystem->ClosePipe(pipe);
1696
cf30933c 1697 if (!(selrawdata && selEvents > 0)) {
67327b72 1698 delete runLoader;
1699 return (result == 0);
1700 }
1701
1702 AliInfo(Form("converting selected by trigger cluster raw data DDL files to DATE file %s", selDateFileName));
1703
76880c9a 1704 snprintf(command, 256, "dateStream -c -s -D -o %s -# %d -C -run %d",
67327b72 1705 selDateFileName,selEvents,runLoader->GetHeader()->GetRun());
1706 FILE* pipe2 = gSystem->OpenPipe(command, "w");
1707
1708 for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
1709
1710 // Get the trigger decision and cluster
f59c50c6 1711 UInt_t detectorPattern = 0;
67327b72 1712 TString detClust;
1713 runLoader->GetEvent(iEvent);
1714 if (!runLoader->LoadTrigger()) {
1715 AliCentralTrigger *aCTP = runLoader->GetTrigger();
1716 if (aCTP->GetClassMask() == 0) continue;
f59c50c6 1717 detectorPattern = aCTP->GetClusterMask();
1718 detClust = AliDAQ::ListOfTriggeredDetectors(detectorPattern);
67327b72 1719 AliInfo(Form("List of detectors to be read out: %s",detClust.Data()));
1720 }
1721
dcf4b43a 1722 fprintf(pipe2, "GDC DetectorPattern %u Timestamp %ld\n", detectorPattern, runLoader->GetHeader()->GetTimeStamp());
67327b72 1723 Float_t ldc = 0;
1724 Int_t prevLDC = -1;
1725
1726 // loop over detectors and DDLs
1727 for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
1728 // Write only raw data from detectors that
1729 // are contained in the trigger cluster(s)
1730 if (!IsSelected(AliDAQ::DetectorName(iDet),detClust)) continue;
1731
1732 for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls(iDet); iDDL++) {
1733
1734 Int_t ddlID = AliDAQ::DdlID(iDet,iDDL);
1735 Int_t ldcID = Int_t(ldc + 0.0001);
1736 ldc += AliDAQ::NumberOfLdcs(iDet) / AliDAQ::NumberOfDdls(iDet);
1737
1738 char rawFileName[256];
76880c9a 1739 snprintf(rawFileName, 256, "raw%d/%s",
67327b72 1740 iEvent, AliDAQ::DdlFileName(iDet,iDDL));
1741
1742 // check existence and size of raw data file
1743 FILE* file = fopen(rawFileName, "rb");
1744 if (!file) continue;
1745 fseek(file, 0, SEEK_END);
1746 unsigned long size = ftell(file);
1747 fclose(file);
1748 if (!size) continue;
1749
1750 if (ldcID != prevLDC) {
1751 fprintf(pipe2, " LDC Id %d\n", ldcID);
1752 prevLDC = ldcID;
1753 }
1754 fprintf(pipe2, " Equipment Id %d Payload %s\n", ddlID, rawFileName);
1755 }
1756 }
1757 }
1758
1759 Int_t result2 = gSystem->ClosePipe(pipe2);
1760
06c7e392 1761 delete runLoader;
67327b72 1762 return ((result == 0) && (result2 == 0));
06c7e392 1763}
1764
1765//_____________________________________________________________________________
1766Bool_t AliSimulation::ConvertDateToRoot(const char* dateFileName,
1767 const char* rootFileName)
1768{
1769// convert a DATE file to a root file with the program "alimdc"
1770
1771 // ALIMDC setup
f28a8d2d 1772 const Int_t kDBSize = 2000000000;
c83eb8f4 1773 const Int_t kTagDBSize = 1000000000;
06c7e392 1774 const Bool_t kFilter = kFALSE;
8ec1d12b 1775 const Int_t kCompression = 1;
06c7e392 1776
1777 char* path = gSystem->Which(gSystem->Getenv("PATH"), "alimdc");
1778 if (!path) {
ac1671c0 1779 AliError("the program alimdc was not found");
06c7e392 1780 if (fStopOnError) return kFALSE;
1781 } else {
1782 delete[] path;
1783 }
1784
ac1671c0 1785 AliInfo(Form("converting DATE file %s to root file %s",
1786 dateFileName, rootFileName));
06c7e392 1787
f732bd7d 1788 const char* rawDBFS[2] = { "/tmp/mdc1", "/tmp/mdc2" };
1789 const char* tagDBFS = "/tmp/mdc1/tags";
f732bd7d 1790
1791 // User defined file system locations
1792 if (gSystem->Getenv("ALIMDC_RAWDB1"))
1793 rawDBFS[0] = gSystem->Getenv("ALIMDC_RAWDB1");
1794 if (gSystem->Getenv("ALIMDC_RAWDB2"))
1795 rawDBFS[1] = gSystem->Getenv("ALIMDC_RAWDB2");
1796 if (gSystem->Getenv("ALIMDC_TAGDB"))
1797 tagDBFS = gSystem->Getenv("ALIMDC_TAGDB");
f732bd7d 1798
1799 gSystem->Exec(Form("rm -rf %s",rawDBFS[0]));
1800 gSystem->Exec(Form("rm -rf %s",rawDBFS[1]));
1801 gSystem->Exec(Form("rm -rf %s",tagDBFS));
f732bd7d 1802
1803 gSystem->Exec(Form("mkdir %s",rawDBFS[0]));
1804 gSystem->Exec(Form("mkdir %s",rawDBFS[1]));
1805 gSystem->Exec(Form("mkdir %s",tagDBFS));
f732bd7d 1806
1807 Int_t result = gSystem->Exec(Form("alimdc %d %d %d %d %s",
1808 kDBSize, kTagDBSize, kFilter, kCompression, dateFileName));
1809 gSystem->Exec(Form("mv %s/*.root %s", rawDBFS[0], rootFileName));
1810
1811 gSystem->Exec(Form("rm -rf %s",rawDBFS[0]));
1812 gSystem->Exec(Form("rm -rf %s",rawDBFS[1]));
1813 gSystem->Exec(Form("rm -rf %s",tagDBFS));
06c7e392 1814
1815 return (result == 0);
0421c3d1 1816}
1817
85a5290f 1818
95601147 1819//_____________________________________________________________________________
06c7e392 1820AliRunLoader* AliSimulation::LoadRun(const char* mode) const
95601147 1821{
1822// delete existing run loaders, open a new one and load gAlice
1823
33c3c91a 1824 delete AliRunLoader::Instance();
95601147 1825 AliRunLoader* runLoader =
1826 AliRunLoader::Open(fGAliceFileName.Data(),
06c7e392 1827 AliConfig::GetDefaultEventFolderName(), mode);
95601147 1828 if (!runLoader) {
ac1671c0 1829 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
95601147 1830 return NULL;
1831 }
1832 runLoader->LoadgAlice();
795e4a22 1833 runLoader->LoadHeader();
95601147 1834 gAlice = runLoader->GetAliRun();
1835 if (!gAlice) {
ac1671c0 1836 AliError(Form("no gAlice object found in file %s",
1837 fGAliceFileName.Data()));
95601147 1838 return NULL;
1839 }
1840 return runLoader;
1841}
1842
85a5290f 1843//_____________________________________________________________________________
05526d44 1844Int_t AliSimulation::GetNSignalPerBkgrd(Int_t nEvents) const
1845{
1846// get or calculate the number of signal events per background event
1847
1848 if (!fBkgrdFileNames) return 1;
1849 Int_t nBkgrdFiles = fBkgrdFileNames->GetEntriesFast();
1850 if (nBkgrdFiles == 0) return 1;
1851
1852 // get the number of signal events
1853 if (nEvents <= 0) {
1854 AliRunLoader* runLoader =
ca30848f 1855 AliRunLoader::Open(fGAliceFileName.Data(), "SIGNAL");
05526d44 1856 if (!runLoader) return 1;
ca30848f 1857
05526d44 1858 nEvents = runLoader->GetNumberOfEvents();
1859 delete runLoader;
1860 }
1861
1862 Int_t result = 0;
1863 for (Int_t iBkgrdFile = 0; iBkgrdFile < nBkgrdFiles; iBkgrdFile++) {
1864 // get the number of background events
1865 const char* fileName = ((TObjString*)
1866 (fBkgrdFileNames->At(iBkgrdFile)))->GetName();
ca30848f 1867 AliRunLoader* runLoader =
05526d44 1868 AliRunLoader::Open(fileName, "BKGRD");
1869 if (!runLoader) continue;
1870 Int_t nBkgrdEvents = runLoader->GetNumberOfEvents();
1871 delete runLoader;
ca30848f 1872
05526d44 1873 // get or calculate the number of signal per background events
1874 Int_t nSignalPerBkgrd = fBkgrdFileNames->At(iBkgrdFile)->GetUniqueID();
1875 if (nSignalPerBkgrd <= 0) {
1876 nSignalPerBkgrd = (nEvents-1) / nBkgrdEvents + 1;
1877 } else if (result && (result != nSignalPerBkgrd)) {
ac1671c0 1878 AliInfo(Form("the number of signal events per background event "
1879 "will be changed from %d to %d for stream %d",
1880 nSignalPerBkgrd, result, iBkgrdFile+1));
05526d44 1881 nSignalPerBkgrd = result;
1882 }
1883
1884 if (!result) result = nSignalPerBkgrd;
1885 if (nSignalPerBkgrd * nBkgrdEvents < nEvents) {
ac1671c0 1886 AliWarning(Form("not enough background events (%d) for %d signal events "
1887 "using %d signal per background events for stream %d",
1888 nBkgrdEvents, nEvents, nSignalPerBkgrd, iBkgrdFile+1));
05526d44 1889 }
1890 }
1891
1892 return result;
1893}
1894
1895//_____________________________________________________________________________
85a5290f 1896Bool_t AliSimulation::IsSelected(TString detName, TString& detectors) const
1897{
1898// check whether detName is contained in detectors
1899// if yes, it is removed from detectors
1900
1901 // check if all detectors are selected
1902 if ((detectors.CompareTo("ALL") == 0) ||
1903 detectors.BeginsWith("ALL ") ||
1904 detectors.EndsWith(" ALL") ||
1905 detectors.Contains(" ALL ")) {
1906 detectors = "ALL";
1907 return kTRUE;
1908 }
1909
1910 // search for the given detector
1911 Bool_t result = kFALSE;
1912 if ((detectors.CompareTo(detName) == 0) ||
1913 detectors.BeginsWith(detName+" ") ||
1914 detectors.EndsWith(" "+detName) ||
1915 detectors.Contains(" "+detName+" ")) {
1916 detectors.ReplaceAll(detName, "");
1917 result = kTRUE;
1918 }
1919
1920 // clean up the detectors string
1921 while (detectors.Contains(" ")) detectors.ReplaceAll(" ", " ");
1922 while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
1923 while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
1924
1925 return result;
1926}
ca30848f 1927
795e4a22 1928//_____________________________________________________________________________
c95d53ea 1929Int_t AliSimulation::ConvertRaw2SDigits(const char* rawDirectory, const char* esdFileName, Int_t N, Int_t nSkip)
ca30848f 1930{
1931//
1932// Steering routine to convert raw data in directory rawDirectory/ to fake SDigits.
1933// These can be used for embedding of MC tracks into RAW data using the standard
1934// merging procedure.
1935//
1936// If an ESD file is given the reconstructed vertex is taken from it and stored in the event header.
1937//
3e2e3ece 1938 if (!gAlice) {
1939 AliError("no gAlice object. Restart aliroot and try again.");
1940 return kFALSE;
1941 }
1942 if (gAlice->Modules()->GetEntries() > 0) {
1943 AliError("gAlice was already run. Restart aliroot and try again.");
1944 return kFALSE;
1945 }
1946
1947 AliInfo(Form("initializing gAlice with config file %s",fConfigFileName.Data()));
1948
1949 gAlice->Announce();
1950
1951 gROOT->LoadMacro(fConfigFileName.Data());
1952 gInterpreter->ProcessLine(gAlice->GetConfigFunction());
1953
1954 if(AliCDBManager::Instance()->GetRun() >= 0) {
1955 SetRunNumber(AliCDBManager::Instance()->GetRun());
1956 } else {
1957 AliWarning("Run number not initialized!!");
1958 }
1959
33c3c91a 1960 AliRunLoader::Instance()->CdGAFile();
ca30848f 1961
3e2e3ece 1962 AliPDG::AddParticlesToPdgDataBase();
1963
f7a1cc68 1964 gMC->SetMagField(TGeoGlobalMagField::Instance()->GetField());
3e2e3ece 1965
55338a9a 1966 gAlice->GetMCApp()->Init();
1967
3e2e3ece 1968 //Must be here because some MCs (G4) adds detectors here and not in Config.C
1969 gAlice->InitLoaders();
33c3c91a 1970 AliRunLoader::Instance()->MakeTree("E");
1971 AliRunLoader::Instance()->LoadKinematics("RECREATE");
1972 AliRunLoader::Instance()->LoadTrackRefs("RECREATE");
1973 AliRunLoader::Instance()->LoadHits("all","RECREATE");
2eab8cf7 1974
3e2e3ece 1975 //
1976 // Save stuff at the beginning of the file to avoid file corruption
33c3c91a 1977 AliRunLoader::Instance()->CdGAFile();
3e2e3ece 1978 gAlice->Write();
ca30848f 1979//
1980// Initialize CDB
795e4a22 1981 InitCDB();
1982 //AliCDBManager* man = AliCDBManager::Instance();
1983 //man->SetRun(0); // Should this come from rawdata header ?
ca30848f 1984
1985 Int_t iDet;
1986 //
1987 // Get the runloader
33c3c91a 1988 AliRunLoader* runLoader = AliRunLoader::Instance();
ca30848f 1989 //
1990 // Open esd file if available
a77627a4 1991 TFile* esdFile = 0;
ca30848f 1992 TTree* treeESD = 0;
a77627a4 1993 AliESDEvent* esd = 0;
2eab8cf7 1994 if (esdFileName && (strlen(esdFileName)>0)) {
a77627a4 1995 esdFile = TFile::Open(esdFileName);
1996 if (esdFile) {
1997 esd = new AliESDEvent();
1998 esdFile->GetObject("esdTree", treeESD);
c95d53ea 1999 if (treeESD) {
2000 esd->ReadFromTree(treeESD);
2001 if (nSkip>0) {
2002 AliInfo(Form("Asking to skip first %d ESDs events",nSkip));
2003 } else {
2004 nSkip=0;
2005 }
2006 }
a77627a4 2007 }
2008 }
6d985680 2009
ca30848f 2010 //
2011 // Create the RawReader
8b31e840 2012 TString fileName(rawDirectory);
5390a0b4 2013 AliRawReader* rawReader = AliRawReader::Create(fileName.Data());
58c338d2 2014 if (!rawReader) return (kFALSE);
2015
8b31e840 2016// if (!fEquipIdMap.IsNull() && fRawReader)
2017// fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
ca30848f 2018 //
2019 // Get list of detectors
2020 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
2021 //
2022 // Get Header
2023 AliHeader* header = runLoader->GetHeader();
ca30848f 2024 // Event loop
2025 Int_t nev = 0;
2026 while(kTRUE) {
2027 if (!(rawReader->NextEvent())) break;
b2f03502 2028 runLoader->SetEventNumber(nev);
2029 runLoader->GetHeader()->Reset(rawReader->GetRunNumber(),
2030 nev, nev);
b2f03502 2031 runLoader->GetEvent(nev);
2eab8cf7 2032 AliInfo(Form("We are at event %d",nev));
ca30848f 2033 //
2034 // Detector loop
b2f03502 2035 TString detStr = fMakeSDigits;
ca30848f 2036 for (iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
2037 AliModule* det = (AliModule*) detArray->At(iDet);
8b31e840 2038 if (!det || !det->IsActive()) continue;
2039 if (IsSelected(det->GetName(), detStr)) {
2eab8cf7 2040 AliInfo(Form("Calling Raw2SDigits for %s", det->GetName()));
8b31e840 2041 det->Raw2SDigits(rawReader);
2042 rawReader->Reset();
2043 }
ca30848f 2044 } // detectors
b2f03502 2045
5b188f2f 2046
ca30848f 2047 //
2048 // If ESD information available obtain reconstructed vertex and store in header.
6d985680 2049 if (treeESD) {
c95d53ea 2050 AliInfo(Form("Selected event %d correspond to event %d in raw and to %d in esd",nev,rawReader->GetEventIndex(),nSkip+rawReader->GetEventIndex()));
2051 treeESD->GetEvent(nSkip+rawReader->GetEventIndex());
ca30848f 2052 const AliESDVertex* esdVertex = esd->GetPrimaryVertex();
2053 Double_t position[3];
2054 esdVertex->GetXYZ(position);
2055 AliGenEventHeader* mcHeader = new AliGenEventHeader("ESD");
2056 TArrayF mcV;
2057 mcV.Set(3);
2058 for (Int_t i = 0; i < 3; i++) mcV[i] = position[i];
2059 mcHeader->SetPrimaryVertex(mcV);
2060 header->Reset(0,nev);
2061 header->SetGenEventHeader(mcHeader);
2eab8cf7 2062 AliInfo(Form("***** Saved vertex %f %f %f \n", position[0], position[1], position[2]));
ca30848f 2063 }
ca30848f 2064//
2065// Finish the event
2d9bb909 2066 runLoader->TreeE()->Fill();
2eab8cf7 2067 AliInfo(Form("Finished event %d",nev));
b2f03502 2068 nev++;
2eab8cf7 2069 if (N>0&&nev>=N)
2070 break;
ca30848f 2071 } // events
2072
2073 delete rawReader;
2074//
2075// Finish the run
2076 runLoader->CdGAFile();
2077 runLoader->WriteHeader("OVERWRITE");
2078 runLoader->WriteRunLoader();
2079
5390a0b4 2080 return nev;
ca30848f 2081}
5b188f2f 2082
3e2e3ece 2083//_____________________________________________________________________________
2084void AliSimulation::FinishRun()
2085{
2086 //
2087 // Called at the end of the run.
2088 //
2089
2090 if(IsLegoRun())
2091 {
2092 AliDebug(1, "Finish Lego");
33c3c91a 2093 AliRunLoader::Instance()->CdGAFile();
3e2e3ece 2094 fLego->FinishRun();
2095 }
2096
2097 // Clean detector information
2098 TIter next(gAlice->Modules());
2099 AliModule *detector;
2100 while((detector = dynamic_cast<AliModule*>(next()))) {
2101 AliDebug(2, Form("%s->FinishRun()", detector->GetName()));
2102 detector->FinishRun();
2103 }
2104
33c3c91a 2105 AliDebug(1, "AliRunLoader::Instance()->WriteHeader(OVERWRITE)");
2106 AliRunLoader::Instance()->WriteHeader("OVERWRITE");
3e2e3ece 2107
2108 // Write AliRun info and all detectors parameters
33c3c91a 2109 AliRunLoader::Instance()->CdGAFile();
3e2e3ece 2110 gAlice->Write(0,TObject::kOverwrite);//write AliRun
33c3c91a 2111 AliRunLoader::Instance()->Write(0,TObject::kOverwrite);//write RunLoader itself
3e2e3ece 2112
2113 if(gAlice->GetMCApp()) gAlice->GetMCApp()->FinishRun();
33c3c91a 2114 AliRunLoader::Instance()->Synchronize();
3e2e3ece 2115}
2116
5b188f2f 2117//_____________________________________________________________________________
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
c4affb19 2129//_____________________________________________________________________________
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
cae21299 2185//_____________________________________________________________________________
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
e3b20d9a 2290//_____________________________________________________________________________
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
795e4a22 2351//_____________________________________________________________________________
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}