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