Important bug-fix. In case of simulation AliGeomManager should load already active...
[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>
fd46e2d2 111#include <TStopwatch.h>
af7ba10c 112#include <TSystem.h>
bfbd5665 113#include <TFile.h>
85a5290f 114
e8d02863 115#include "AliCDBStorage.h"
116#include "AliCDBEntry.h"
117#include "AliCDBManager.h"
25be1e5c 118#include "AliGeomManager.h"
e8d02863 119#include "AliAlignObj.h"
120#include "AliCentralTrigger.h"
362c9d61 121#include "AliDAQ.h"
af7ba10c 122#include "AliDigitizer.h"
123#include "AliGenerator.h"
e8d02863 124#include "AliLog.h"
af7ba10c 125#include "AliModule.h"
126#include "AliRun.h"
127#include "AliRunDigitizer.h"
128#include "AliRunLoader.h"
129#include "AliSimulation.h"
130#include "AliVertexGenFile.h"
a5a091ce 131#include "AliCentralTrigger.h"
007155cc 132#include "AliCTPRawData.h"
ca30848f 133#include "AliRawReaderFile.h"
134#include "AliESD.h"
135#include "AliHeader.h"
136#include "AliGenEventHeader.h"
b856a511 137#include "AliMC.h"
85a5290f 138
139ClassImp(AliSimulation)
140
b856a511 141AliSimulation *AliSimulation::fgInstance = 0;
85a5290f 142
143//_____________________________________________________________________________
024cf675 144AliSimulation::AliSimulation(const char* configFileName, const char* cdbUri,
95601147 145 const char* name, const char* title) :
146 TNamed(name, title),
147
148 fRunGeneration(kTRUE),
149 fRunSimulation(kTRUE),
024cf675 150 fLoadAlignFromCDB(kTRUE),
25be1e5c 151 fLoadAlObjsListOfDets("ALL"),
95601147 152 fMakeSDigits("ALL"),
153 fMakeDigits("ALL"),
a5a091ce 154 fMakeTrigger(""),
95601147 155 fMakeDigitsFromHits(""),
0421c3d1 156 fWriteRawData(""),
06c7e392 157 fRawDataFileName(""),
158 fDeleteIntermediateFiles(kFALSE),
95601147 159 fStopOnError(kFALSE),
160
161 fNEvents(1),
162 fConfigFileName(configFileName),
163 fGAliceFileName("galice.root"),
18b43626 164 fEventsPerFile(),
95601147 165 fBkgrdFileNames(NULL),
995ad051 166 fAlignObjArray(NULL),
04bae0a0 167 fUseBkgrdVertex(kTRUE),
024cf675 168 fRegionOfInterest(kFALSE),
ec92bee0 169 fCDBUri(cdbUri),
ca30848f 170 fSpecCDBUri(),
171 fEmbeddingFlag(kFALSE)
85a5290f 172{
173// create simulation object with default parameters
b856a511 174 fgInstance = this;
0421c3d1 175 SetGAliceFile("galice.root");
85a5290f 176}
177
178//_____________________________________________________________________________
179AliSimulation::AliSimulation(const AliSimulation& sim) :
95601147 180 TNamed(sim),
181
182 fRunGeneration(sim.fRunGeneration),
183 fRunSimulation(sim.fRunSimulation),
024cf675 184 fLoadAlignFromCDB(sim.fLoadAlignFromCDB),
25be1e5c 185 fLoadAlObjsListOfDets(sim.fLoadAlObjsListOfDets),
95601147 186 fMakeSDigits(sim.fMakeSDigits),
187 fMakeDigits(sim.fMakeDigits),
a5a091ce 188 fMakeTrigger(sim.fMakeTrigger),
95601147 189 fMakeDigitsFromHits(sim.fMakeDigitsFromHits),
0421c3d1 190 fWriteRawData(sim.fWriteRawData),
06c7e392 191 fRawDataFileName(""),
192 fDeleteIntermediateFiles(kFALSE),
95601147 193 fStopOnError(sim.fStopOnError),
194
195 fNEvents(sim.fNEvents),
196 fConfigFileName(sim.fConfigFileName),
197 fGAliceFileName(sim.fGAliceFileName),
18b43626 198 fEventsPerFile(),
95601147 199 fBkgrdFileNames(NULL),
995ad051 200 fAlignObjArray(NULL),
04bae0a0 201 fUseBkgrdVertex(sim.fUseBkgrdVertex),
024cf675 202 fRegionOfInterest(sim.fRegionOfInterest),
ec92bee0 203 fCDBUri(sim.fCDBUri),
ca30848f 204 fSpecCDBUri(),
205 fEmbeddingFlag(sim.fEmbeddingFlag)
85a5290f 206{
207// copy constructor
208
18b43626 209 for (Int_t i = 0; i < sim.fEventsPerFile.GetEntriesFast(); i++) {
210 if (!sim.fEventsPerFile[i]) continue;
211 fEventsPerFile.Add(sim.fEventsPerFile[i]->Clone());
212 }
213
85a5290f 214 fBkgrdFileNames = new TObjArray;
215 for (Int_t i = 0; i < sim.fBkgrdFileNames->GetEntriesFast(); i++) {
216 if (!sim.fBkgrdFileNames->At(i)) continue;
217 fBkgrdFileNames->Add(sim.fBkgrdFileNames->At(i)->Clone());
218 }
ec92bee0 219
220 for (Int_t i = 0; i < sim.fSpecCDBUri.GetEntriesFast(); i++) {
221 if (sim.fSpecCDBUri[i]) fSpecCDBUri.Add(sim.fSpecCDBUri[i]->Clone());
222 }
b856a511 223 fgInstance = this;
85a5290f 224}
225
226//_____________________________________________________________________________
227AliSimulation& AliSimulation::operator = (const AliSimulation& sim)
228{
229// assignment operator
230
231 this->~AliSimulation();
232 new(this) AliSimulation(sim);
233 return *this;
234}
235
236//_____________________________________________________________________________
237AliSimulation::~AliSimulation()
238{
239// clean up
240
18b43626 241 fEventsPerFile.Delete();
024cf675 242// if(fAlignObjArray) fAlignObjArray->Delete(); // fAlignObjArray->RemoveAll() ???
243// delete fAlignObjArray; fAlignObjArray=0;
18b43626 244
95601147 245 if (fBkgrdFileNames) {
246 fBkgrdFileNames->Delete();
247 delete fBkgrdFileNames;
248 }
ec92bee0 249
250 fSpecCDBUri.Delete();
b856a511 251 if (fgInstance==this) fgInstance = 0;
85a5290f 252}
253
254
255//_____________________________________________________________________________
256void AliSimulation::SetNumberOfEvents(Int_t nEvents)
257{
258// set the number of events for one run
259
260 fNEvents = nEvents;
261}
262
263//_____________________________________________________________________________
ec92bee0 264void AliSimulation::InitCDBStorage()
024cf675 265{
266// activate a default CDB storage
267// First check if we have any CDB storage set, because it is used
268// to retrieve the calibration and alignment constants
269
270 AliCDBManager* man = AliCDBManager::Instance();
ec92bee0 271 if (man->IsDefaultStorageSet())
024cf675 272 {
ec92bee0 273 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
274 AliWarning("Default CDB storage has been already set !");
275 AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fCDBUri.Data()));
276 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
277 fCDBUri = "";
278 }
279 else {
b8ec52f6 280 AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
281 AliDebug(2, Form("Default CDB storage is set to: %s",fCDBUri.Data()));
282 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
ec92bee0 283 man->SetDefaultStorage(fCDBUri);
284 }
285
286 // Now activate the detector specific CDB storage locations
287 for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
288 TObject* obj = fSpecCDBUri[i];
289 if (!obj) continue;
b8ec52f6 290 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
291 AliDebug(2, Form("Specific CDB storage for %s is set to: %s",obj->GetName(),obj->GetTitle()));
292 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
c3a7b59a 293 man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
ec92bee0 294 }
727d0766 295 man->Print();
024cf675 296}
297
298//_____________________________________________________________________________
299void AliSimulation::SetDefaultStorage(const char* uri) {
ec92bee0 300// Store the desired default CDB storage location
301// Activate it later within the Run() method
024cf675 302
ec92bee0 303 fCDBUri = uri;
024cf675 304
305}
306
307//_____________________________________________________________________________
c3a7b59a 308void AliSimulation::SetSpecificStorage(const char* calibType, const char* uri) {
ec92bee0 309// Store a detector-specific CDB storage location
310// Activate it later within the Run() method
024cf675 311
c3a7b59a 312 AliCDBPath aPath(calibType);
313 if(!aPath.IsValid()){
314 AliError(Form("Not a valid path: %s", calibType));
315 return;
316 }
317
318 TObject* obj = fSpecCDBUri.FindObject(calibType);
ec92bee0 319 if (obj) fSpecCDBUri.Remove(obj);
c3a7b59a 320 fSpecCDBUri.Add(new TNamed(calibType, uri));
024cf675 321
322}
323
324//_____________________________________________________________________________
85a5290f 325void AliSimulation::SetConfigFile(const char* fileName)
326{
327// set the name of the config file
328
329 fConfigFileName = fileName;
330}
331
332//_____________________________________________________________________________
0421c3d1 333void AliSimulation::SetGAliceFile(const char* fileName)
334{
335// set the name of the galice file
336// the path is converted to an absolute one if it is relative
337
338 fGAliceFileName = fileName;
339 if (!gSystem->IsAbsoluteFileName(fGAliceFileName)) {
340 char* absFileName = gSystem->ConcatFileName(gSystem->WorkingDirectory(),
341 fGAliceFileName);
342 fGAliceFileName = absFileName;
343 delete[] absFileName;
344 }
ac1671c0 345
346 AliDebug(2, Form("galice file name set to %s", fileName));
0421c3d1 347}
348
349//_____________________________________________________________________________
18b43626 350void AliSimulation::SetEventsPerFile(const char* detector, const char* type,
351 Int_t nEvents)
352{
353// set the number of events per file for the given detector and data type
354// ("Hits", "Summable Digits", "Digits", "Reconstructed Points" or "Tracks")
355
356 TNamed* obj = new TNamed(detector, type);
357 obj->SetUniqueID(nEvents);
358 fEventsPerFile.Add(obj);
359}
360
361//_____________________________________________________________________________
6bae477a 362Bool_t AliSimulation::MisalignGeometry(AliRunLoader *runLoader)
363{
364 // Read the alignment objects from CDB.
365 // Each detector is supposed to have the
366 // alignment objects in DET/Align/Data CDB path.
367 // All the detector objects are then collected,
368 // sorted by geometry level (starting from ALIC) and
369 // then applied to the TGeo geometry.
370 // Finally an overlaps check is performed.
371
0717eed2 372 if (!gGeoManager || !gGeoManager->IsClosed()) {
373 AliError("Can't apply the misalignment! gGeoManager doesn't exist or it is still opened!");
374 return kFALSE;
375 }
6bae477a 376 Bool_t delRunLoader = kFALSE;
377 if (!runLoader) {
378 runLoader = LoadRun("READ");
379 if (!runLoader) return kFALSE;
380 delRunLoader = kTRUE;
381 }
382
b856a511 383 // Export ideal geometry
0717eed2 384 gGeoManager->Export("geometry.root");
b856a511 385
25be1e5c 386 // Load alignment data from CDB and apply to geometry through AliGeomManager
6bae477a 387 if(fLoadAlignFromCDB){
25be1e5c 388
389 TString detStr = fLoadAlObjsListOfDets;
390 TString loadAlObjsListOfDets = "";
391
392 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
393 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
394 AliModule* det = (AliModule*) detArray->At(iDet);
395 if (!det || !det->IsActive()) continue;
396 if (IsSelected(det->GetName(), detStr)) {
0717eed2 397 //add det to list of dets to be aligned from CDB
398 loadAlObjsListOfDets += det->GetName();
399 loadAlObjsListOfDets += " ";
25be1e5c 400 }
401 } // end loop over detectors
45daac75 402 AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
25be1e5c 403 }else{
404 // Check if the array with alignment objects was
405 // provided by the user. If yes, apply the objects
406 // to the present TGeo geometry
407 if (fAlignObjArray) {
45daac75 408 if (AliGeomManager::ApplyAlignObjsToGeom(*fAlignObjArray) == kFALSE) {
0717eed2 409 AliError("The misalignment of one or more volumes failed!"
410 "Compare the list of simulated detectors and the list of detector alignment data!");
411 if (delRunLoader) delete runLoader;
412 return kFALSE;
6bae477a 413 }
414 }
6bae477a 415 }
416
ef7ff1f9 417 // Update the internal geometry of modules (ITS needs it)
25be1e5c 418 TString detStr = fLoadAlObjsListOfDets;
ef7ff1f9 419 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
420 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
421
422 AliModule* det = (AliModule*) detArray->At(iDet);
423 if (!det || !det->IsActive()) continue;
424 if (IsSelected(det->GetName(), detStr)) {
425 det->UpdateInternalGeometry();
426 }
427 } // end loop over detectors
428
429
6bae477a 430 if (delRunLoader) delete runLoader;
431
432 return kTRUE;
433}
434
435
436//_____________________________________________________________________________
437Bool_t AliSimulation::SetRunNumber()
438{
439 // Set the CDB manager run number
440 // The run number is retrieved from gAlice
441
442 if(AliCDBManager::Instance()->GetRun() < 0) {
443 AliRunLoader* runLoader = LoadRun("READ");
444 if (!runLoader) return kFALSE;
445 else {
446 AliCDBManager::Instance()->SetRun(runLoader->GetAliRun()->GetRunNumber());
447 AliInfo(Form("Run number: %d",AliCDBManager::Instance()->GetRun()));
448 delete runLoader;
449 }
450 }
451 return kTRUE;
452}
453
454//_____________________________________________________________________________
85a5290f 455void AliSimulation::MergeWith(const char* fileName, Int_t nSignalPerBkgrd)
456{
457// add a file with background events for merging
458
459 TObjString* fileNameStr = new TObjString(fileName);
460 fileNameStr->SetUniqueID(nSignalPerBkgrd);
95601147 461 if (!fBkgrdFileNames) fBkgrdFileNames = new TObjArray;
85a5290f 462 fBkgrdFileNames->Add(fileNameStr);
463}
464
ca30848f 465void AliSimulation::EmbedInto(const char* fileName, Int_t nSignalPerBkgrd)
466{
467// add a file with background events for embeddin
468 MergeWith(fileName, nSignalPerBkgrd);
469 fEmbeddingFlag = kTRUE;
470}
85a5290f 471
472//_____________________________________________________________________________
473Bool_t AliSimulation::Run(Int_t nEvents)
474{
475// run the generation, simulation and digitization
476
ec92bee0 477 InitCDBStorage();
b0314964 478
85a5290f 479 if (nEvents > 0) fNEvents = nEvents;
480
481 // generation and simulation -> hits
482 if (fRunGeneration) {
85a5290f 483 if (!RunSimulation()) if (fStopOnError) return kFALSE;
484 }
485
6bae477a 486 // Set run number in CDBManager (if it is not already set in RunSimulation)
487 if (!SetRunNumber()) if (fStopOnError) return kFALSE;
488
25be1e5c 489 // If RunSimulation was not called, load the geometry and misalign it
6bae477a 490 if (!gGeoManager) {
45daac75 491 AliGeomManager::LoadGeometry("geometry.root");
6bae477a 492 if (!gGeoManager) if (fStopOnError) return kFALSE;
25be1e5c 493 // Initialize the geometry manager (if not already done)
494 if(!MisalignGeometry()) if (fStopOnError) return kFALSE;
6bae477a 495 }
25be1e5c 496
85a5290f 497 // hits -> summable digits
498 if (!fMakeSDigits.IsNull()) {
499 if (!RunSDigitization(fMakeSDigits)) if (fStopOnError) return kFALSE;
500 }
501
502 // summable digits -> digits
503 if (!fMakeDigits.IsNull()) {
504 if (!RunDigitization(fMakeDigits, fMakeDigitsFromHits)) {
505 if (fStopOnError) return kFALSE;
506 }
507 }
508
509 // hits -> digits
510 if (!fMakeDigitsFromHits.IsNull()) {
95601147 511 if (fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
ac1671c0 512 AliWarning(Form("Merging and direct creation of digits from hits "
513 "was selected for some detectors. "
514 "No merging will be done for the following detectors: %s",
515 fMakeDigitsFromHits.Data()));
85a5290f 516 }
517 if (!RunHitsDigitization(fMakeDigitsFromHits)) {
518 if (fStopOnError) return kFALSE;
519 }
520 }
521
a5a091ce 522 // digits -> trigger
087426de 523 if (!RunTrigger(fMakeTrigger)) {
524 if (fStopOnError) return kFALSE;
a5a091ce 525 }
526
0421c3d1 527 // digits -> raw data
528 if (!fWriteRawData.IsNull()) {
06c7e392 529 if (!WriteRawData(fWriteRawData, fRawDataFileName,
530 fDeleteIntermediateFiles)) {
0421c3d1 531 if (fStopOnError) return kFALSE;
532 }
533 }
534
85a5290f 535 return kTRUE;
536}
537
538//_____________________________________________________________________________
a5a091ce 539Bool_t AliSimulation::RunTrigger(const char* descriptors)
540{
541 // run the trigger
542
bacbe0fd 543 TStopwatch stopwatch;
544 stopwatch.Start();
a5a091ce 545
bacbe0fd 546 AliRunLoader* runLoader = LoadRun("READ");
547 if (!runLoader) return kFALSE;
548 TString des = descriptors;
549
087426de 550 if (des.IsNull()) {
551 if (gAlice->GetTriggerDescriptor() != "") {
552 des = gAlice->GetTriggerDescriptor();
553 }
554 else {
555 AliWarning("No trigger descriptor is specified. Skipping the trigger simulation...");
556 return kTRUE;
557 }
558 }
559
0f46f5fa 560 runLoader->MakeTree( "GG" );
bacbe0fd 561 AliCentralTrigger* aCTP = runLoader->GetTrigger();
a5a091ce 562 // Load Descriptors
bacbe0fd 563 aCTP->LoadDescriptor( des );
a5a091ce 564
565 // digits -> trigger
bacbe0fd 566 if( !aCTP->RunTrigger( runLoader ) ) {
a5a091ce 567 if (fStopOnError) {
bacbe0fd 568 // delete aCTP;
a5a091ce 569 return kFALSE;
570 }
bacbe0fd 571 }
a5a091ce 572
bacbe0fd 573 AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
574 stopwatch.RealTime(),stopwatch.CpuTime()));
a5a091ce 575
bacbe0fd 576 delete runLoader;
a5a091ce 577
bacbe0fd 578 return kTRUE;
a5a091ce 579}
580
007155cc 581//_____________________________________________________________________________
582Bool_t AliSimulation::WriteTriggerRawData()
583{
584 // Writes the CTP (trigger) DDL raw data
585 // Details of the format are given in the
586 // trigger TDR - pages 134 and 135.
587 AliCTPRawData writer;
588 writer.RawData();
a5a091ce 589
007155cc 590 return kTRUE;
591}
a5a091ce 592
593//_____________________________________________________________________________
95601147 594Bool_t AliSimulation::RunSimulation(Int_t nEvents)
85a5290f 595{
596// run the generation and simulation
597
4df28b43 598 TStopwatch stopwatch;
599 stopwatch.Start();
600
95601147 601 if (!gAlice) {
ac1671c0 602 AliError("no gAlice object. Restart aliroot and try again.");
95601147 603 return kFALSE;
604 }
605 if (gAlice->Modules()->GetEntries() > 0) {
ac1671c0 606 AliError("gAlice was already run. Restart aliroot and try again.");
95601147 607 return kFALSE;
608 }
609
ac1671c0 610 AliInfo(Form("initializing gAlice with config file %s",
611 fConfigFileName.Data()));
815c2b38 612 StdoutToAliInfo(StderrToAliError(
613 gAlice->Init(fConfigFileName.Data());
614 ););
995ad051 615
087426de 616 // Get the trigger descriptor string
617 // Either from AliSimulation or from
618 // gAlice
619 if (fMakeTrigger.IsNull()) {
620 if (gAlice->GetTriggerDescriptor() != "")
621 fMakeTrigger = gAlice->GetTriggerDescriptor();
622 }
623 else
624 gAlice->SetTriggerDescriptor(fMakeTrigger.Data());
625
6bae477a 626 // Set run number in CDBManager
024cf675 627 AliInfo(Form("Run number: %d",AliCDBManager::Instance()->GetRun()));
628
629 AliRunLoader* runLoader = gAlice->GetRunLoader();
630 if (!runLoader) {
631 AliError(Form("gAlice has no run loader object. "
632 "Check your config file: %s", fConfigFileName.Data()));
633 return kFALSE;
634 }
635 SetGAliceFile(runLoader->GetFileName());
636
6bae477a 637 // Misalign geometry
caf9c464 638#if ROOT_VERSION_CODE < 331527
639 MisalignGeometry(runLoader);
640#endif
995ad051 641
024cf675 642// AliRunLoader* runLoader = gAlice->GetRunLoader();
643// if (!runLoader) {
644// AliError(Form("gAlice has no run loader object. "
645// "Check your config file: %s", fConfigFileName.Data()));
646// return kFALSE;
647// }
648// SetGAliceFile(runLoader->GetFileName());
85a5290f 649
04bae0a0 650 if (!gAlice->Generator()) {
ac1671c0 651 AliError(Form("gAlice has no generator object. "
652 "Check your config file: %s", fConfigFileName.Data()));
04bae0a0 653 return kFALSE;
654 }
05526d44 655 if (nEvents <= 0) nEvents = fNEvents;
04bae0a0 656
657 // get vertex from background file in case of merging
658 if (fUseBkgrdVertex &&
659 fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
05526d44 660 Int_t signalPerBkgrd = GetNSignalPerBkgrd(nEvents);
04bae0a0 661 const char* fileName = ((TObjString*)
662 (fBkgrdFileNames->At(0)))->GetName();
ac1671c0 663 AliInfo(Form("The vertex will be taken from the background "
664 "file %s with nSignalPerBackground = %d",
665 fileName, signalPerBkgrd));
04bae0a0 666 AliVertexGenFile* vtxGen = new AliVertexGenFile(fileName, signalPerBkgrd);
667 gAlice->Generator()->SetVertexGenerator(vtxGen);
668 }
669
85a5290f 670 if (!fRunSimulation) {
85a5290f 671 gAlice->Generator()->SetTrackingFlag(0);
672 }
673
18b43626 674 // set the number of events per file for given detectors and data types
675 for (Int_t i = 0; i < fEventsPerFile.GetEntriesFast(); i++) {
676 if (!fEventsPerFile[i]) continue;
677 const char* detName = fEventsPerFile[i]->GetName();
678 const char* typeName = fEventsPerFile[i]->GetTitle();
679 TString loaderName(detName);
680 loaderName += "Loader";
681 AliLoader* loader = runLoader->GetLoader(loaderName);
682 if (!loader) {
ac1671c0 683 AliError(Form("RunSimulation", "no loader for %s found\n"
684 "Number of events per file not set for %s %s",
685 detName, typeName, detName));
18b43626 686 continue;
687 }
688 AliDataLoader* dataLoader =
689 loader->GetDataLoader(typeName);
690 if (!dataLoader) {
ac1671c0 691 AliError(Form("no data loader for %s found\n"
692 "Number of events per file not set for %s %s",
693 typeName, detName, typeName));
18b43626 694 continue;
695 }
696 dataLoader->SetNumberOfEventsPerFile(fEventsPerFile[i]->GetUniqueID());
ac1671c0 697 AliDebug(1, Form("number of events per file set to %d for %s %s",
698 fEventsPerFile[i]->GetUniqueID(), detName, typeName));
18b43626 699 }
700
ac1671c0 701 AliInfo("running gAlice");
815c2b38 702 StdoutToAliInfo(StderrToAliError(
703 gAlice->Run(nEvents);
704 ););
95601147 705
706 delete runLoader;
85a5290f 707
5f8272e1 708 AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
709 stopwatch.RealTime(),stopwatch.CpuTime()));
4df28b43 710
85a5290f 711 return kTRUE;
712}
713
714//_____________________________________________________________________________
95601147 715Bool_t AliSimulation::RunSDigitization(const char* detectors)
85a5290f 716{
717// run the digitization and produce summable digits
718
4df28b43 719 TStopwatch stopwatch;
720 stopwatch.Start();
721
95601147 722 AliRunLoader* runLoader = LoadRun();
723 if (!runLoader) return kFALSE;
724
85a5290f 725 TString detStr = detectors;
95601147 726 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
85a5290f 727 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
728 AliModule* det = (AliModule*) detArray->At(iDet);
729 if (!det || !det->IsActive()) continue;
730 if (IsSelected(det->GetName(), detStr)) {
ac1671c0 731 AliInfo(Form("creating summable digits for %s", det->GetName()));
de76655b 732 TStopwatch stopwatchDet;
733 stopwatchDet.Start();
85a5290f 734 det->Hits2SDigits();
5f8272e1 735 AliInfo(Form("Execution time for %s: R:%.2fs C:%.2fs",
736 det->GetName(),stopwatchDet.RealTime(),stopwatchDet.CpuTime()));
85a5290f 737 }
738 }
739
740 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
ac1671c0 741 AliError(Form("the following detectors were not found: %s",
742 detStr.Data()));
85a5290f 743 if (fStopOnError) return kFALSE;
744 }
745
95601147 746 delete runLoader;
747
5f8272e1 748 AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
749 stopwatch.RealTime(),stopwatch.CpuTime()));
4df28b43 750
85a5290f 751 return kTRUE;
752}
753
754
755//_____________________________________________________________________________
95601147 756Bool_t AliSimulation::RunDigitization(const char* detectors,
757 const char* excludeDetectors)
85a5290f 758{
759// run the digitization and produce digits from sdigits
760
4df28b43 761 TStopwatch stopwatch;
762 stopwatch.Start();
763
95601147 764 while (AliRunLoader::GetRunLoader()) delete AliRunLoader::GetRunLoader();
765 if (gAlice) delete gAlice;
766 gAlice = NULL;
767
768 Int_t nStreams = 1;
05526d44 769 if (fBkgrdFileNames) nStreams = fBkgrdFileNames->GetEntriesFast() + 1;
770 Int_t signalPerBkgrd = GetNSignalPerBkgrd();
85a5290f 771 AliRunDigitizer* manager = new AliRunDigitizer(nStreams, signalPerBkgrd);
ca30848f 772 // manager->SetEmbeddingFlag(fEmbeddingFlag);
85a5290f 773 manager->SetInputStream(0, fGAliceFileName.Data());
774 for (Int_t iStream = 1; iStream < nStreams; iStream++) {
775 const char* fileName = ((TObjString*)
776 (fBkgrdFileNames->At(iStream-1)))->GetName();
777 manager->SetInputStream(iStream, fileName);
778 }
779
780 TString detStr = detectors;
781 TString detExcl = excludeDetectors;
95601147 782 manager->GetInputStream(0)->ImportgAlice();
783 AliRunLoader* runLoader =
784 AliRunLoader::GetRunLoader(manager->GetInputStream(0)->GetFolderName());
785 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
85a5290f 786 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
787 AliModule* det = (AliModule*) detArray->At(iDet);
788 if (!det || !det->IsActive()) continue;
789 if (IsSelected(det->GetName(), detStr) &&
790 !IsSelected(det->GetName(), detExcl)) {
4df28b43 791 AliDigitizer* digitizer = det->CreateDigitizer(manager);
ca30848f 792
4df28b43 793 if (!digitizer) {
ac1671c0 794 AliError(Form("no digitizer for %s", det->GetName()));
85a5290f 795 if (fStopOnError) return kFALSE;
4df28b43 796 } else {
797 digitizer->SetRegionOfInterest(fRegionOfInterest);
85a5290f 798 }
799 }
800 }
801
802 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
ac1671c0 803 AliError(Form("the following detectors were not found: %s",
804 detStr.Data()));
85a5290f 805 if (fStopOnError) return kFALSE;
806 }
807
808 if (!manager->GetListOfTasks()->IsEmpty()) {
ac1671c0 809 AliInfo("executing digitization");
85a5290f 810 manager->Exec("");
811 }
95601147 812
85a5290f 813 delete manager;
814
5f8272e1 815 AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
816 stopwatch.RealTime(),stopwatch.CpuTime()));
817
85a5290f 818 return kTRUE;
819}
820
821//_____________________________________________________________________________
95601147 822Bool_t AliSimulation::RunHitsDigitization(const char* detectors)
85a5290f 823{
824// run the digitization and produce digits from hits
825
4df28b43 826 TStopwatch stopwatch;
827 stopwatch.Start();
828
591f51bb 829 AliRunLoader* runLoader = LoadRun("READ");
95601147 830 if (!runLoader) return kFALSE;
831
85a5290f 832 TString detStr = detectors;
95601147 833 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
85a5290f 834 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
835 AliModule* det = (AliModule*) detArray->At(iDet);
836 if (!det || !det->IsActive()) continue;
837 if (IsSelected(det->GetName(), detStr)) {
ac1671c0 838 AliInfo(Form("creating digits from hits for %s", det->GetName()));
85a5290f 839 det->Hits2Digits();
840 }
841 }
842
843 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
ac1671c0 844 AliError(Form("the following detectors were not found: %s",
845 detStr.Data()));
85a5290f 846 if (fStopOnError) return kFALSE;
847 }
848
b17cac0f 849 delete runLoader;
591f51bb 850 //PH Temporary fix to avoid interference with the PHOS loder/getter
851 //PH The problem has to be solved in more general way 09/06/05
95601147 852
5f8272e1 853 AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
854 stopwatch.RealTime(),stopwatch.CpuTime()));
4df28b43 855
85a5290f 856 return kTRUE;
857}
858
0421c3d1 859//_____________________________________________________________________________
06c7e392 860Bool_t AliSimulation::WriteRawData(const char* detectors,
861 const char* fileName,
862 Bool_t deleteIntermediateFiles)
0421c3d1 863{
864// convert the digits to raw data
06c7e392 865// First DDL raw data files for the given detectors are created.
866// If a file name is given, the DDL files are then converted to a DATE file.
867// If deleteIntermediateFiles is true, the DDL raw files are deleted
868// afterwards.
869// If the file name has the extension ".root", the DATE file is converted
870// to a root file.
871// If deleteIntermediateFiles is true, the DATE file is deleted afterwards.
0421c3d1 872
873 TStopwatch stopwatch;
874 stopwatch.Start();
875
06c7e392 876 if (!WriteRawFiles(detectors)) {
877 if (fStopOnError) return kFALSE;
878 }
879
880 TString dateFileName(fileName);
881 if (!dateFileName.IsNull()) {
882 Bool_t rootOutput = dateFileName.EndsWith(".root");
883 if (rootOutput) dateFileName += ".date";
884 if (!ConvertRawFilesToDate(dateFileName)) {
885 if (fStopOnError) return kFALSE;
886 }
887 if (deleteIntermediateFiles) {
888 AliRunLoader* runLoader = LoadRun("READ");
889 if (runLoader) for (Int_t iEvent = 0;
890 iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
891 char command[256];
892 sprintf(command, "rm -r raw%d", iEvent);
893 gSystem->Exec(command);
894 }
895 }
896
897 if (rootOutput) {
898 if (!ConvertDateToRoot(dateFileName, fileName)) {
899 if (fStopOnError) return kFALSE;
900 }
901 if (deleteIntermediateFiles) {
902 gSystem->Unlink(dateFileName);
903 }
904 }
905 }
906
5f8272e1 907 AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
908 stopwatch.RealTime(),stopwatch.CpuTime()));
06c7e392 909
910 return kTRUE;
911}
912
913//_____________________________________________________________________________
914Bool_t AliSimulation::WriteRawFiles(const char* detectors)
915{
916// convert the digits to raw data DDL files
917
918 AliRunLoader* runLoader = LoadRun("READ");
0421c3d1 919 if (!runLoader) return kFALSE;
920
06c7e392 921 // write raw data to DDL files
0421c3d1 922 for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
ac1671c0 923 AliInfo(Form("processing event %d", iEvent));
0421c3d1 924 runLoader->GetEvent(iEvent);
925 TString baseDir = gSystem->WorkingDirectory();
926 char dirName[256];
927 sprintf(dirName, "raw%d", iEvent);
928 gSystem->MakeDirectory(dirName);
929 if (!gSystem->ChangeDirectory(dirName)) {
ac1671c0 930 AliError(Form("couldn't change to directory %s", dirName));
0421c3d1 931 if (fStopOnError) return kFALSE; else continue;
932 }
933
934 TString detStr = detectors;
935 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
936 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
937 AliModule* det = (AliModule*) detArray->At(iDet);
938 if (!det || !det->IsActive()) continue;
939 if (IsSelected(det->GetName(), detStr)) {
ac1671c0 940 AliInfo(Form("creating raw data from digits for %s", det->GetName()));
0421c3d1 941 det->Digits2Raw();
942 }
943 }
944
007155cc 945 if (!WriteTriggerRawData())
946 if (fStopOnError) return kFALSE;
947
0421c3d1 948 gSystem->ChangeDirectory(baseDir);
949 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
ac1671c0 950 AliError(Form("the following detectors were not found: %s",
951 detStr.Data()));
0421c3d1 952 if (fStopOnError) return kFALSE;
953 }
954 }
955
956 delete runLoader;
06c7e392 957 return kTRUE;
958}
0421c3d1 959
06c7e392 960//_____________________________________________________________________________
961Bool_t AliSimulation::ConvertRawFilesToDate(const char* dateFileName)
962{
963// convert raw data DDL files to a DATE file with the program "dateStream"
964
06c7e392 965 char* path = gSystem->Which(gSystem->Getenv("PATH"), "dateStream");
966 if (!path) {
ac1671c0 967 AliError("the program dateStream was not found");
06c7e392 968 if (fStopOnError) return kFALSE;
969 } else {
970 delete[] path;
971 }
0421c3d1 972
06c7e392 973 AliRunLoader* runLoader = LoadRun("READ");
974 if (!runLoader) return kFALSE;
975
ac1671c0 976 AliInfo(Form("converting raw data DDL files to DATE file %s", dateFileName));
06c7e392 977 char command[256];
f28a8d2d 978 // Note the option -s. It is used in order to avoid
979 // the generation of SOR/EOR events.
980 sprintf(command, "dateStream -s -D -o %s -# %d -C",
06c7e392 981 dateFileName, runLoader->GetNumberOfEvents());
982 FILE* pipe = gSystem->OpenPipe(command, "w");
983
984 for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
985 fprintf(pipe, "GDC\n");
986 Float_t ldc = 0;
987 Int_t prevLDC = -1;
988
989 // loop over detectors and DDLs
362c9d61 990 for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
991 for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls(iDet); iDDL++) {
06c7e392 992
362c9d61 993 Int_t ddlID = AliDAQ::DdlID(iDet,iDDL);
06c7e392 994 Int_t ldcID = Int_t(ldc + 0.0001);
362c9d61 995 ldc += AliDAQ::NumberOfLdcs(iDet) / AliDAQ::NumberOfDdls(iDet);
06c7e392 996
997 char rawFileName[256];
362c9d61 998 sprintf(rawFileName, "raw%d/%s",
999 iEvent, AliDAQ::DdlFileName(iDet,iDDL));
06c7e392 1000
1001 // check existence and size of raw data file
1002 FILE* file = fopen(rawFileName, "rb");
1003 if (!file) continue;
1004 fseek(file, 0, SEEK_END);
1005 unsigned long size = ftell(file);
aa04f81b 1006 fclose(file);
1007 if (!size) continue;
06c7e392 1008
1009 if (ldcID != prevLDC) {
1010 fprintf(pipe, " LDC Id %d\n", ldcID);
1011 prevLDC = ldcID;
1012 }
1013 fprintf(pipe, " Equipment Id %d Payload %s\n", ddlID, rawFileName);
1014 }
1015 }
1016 }
1017
1018 Int_t result = gSystem->ClosePipe(pipe);
1019
1020 delete runLoader;
1021 return (result == 0);
1022}
1023
1024//_____________________________________________________________________________
1025Bool_t AliSimulation::ConvertDateToRoot(const char* dateFileName,
1026 const char* rootFileName)
1027{
1028// convert a DATE file to a root file with the program "alimdc"
1029
1030 // ALIMDC setup
f28a8d2d 1031 const Int_t kDBSize = 2000000000;
c83eb8f4 1032 const Int_t kTagDBSize = 1000000000;
06c7e392 1033 const Bool_t kFilter = kFALSE;
f28a8d2d 1034 const Int_t kCompression = 0;
06c7e392 1035
1036 char* path = gSystem->Which(gSystem->Getenv("PATH"), "alimdc");
1037 if (!path) {
ac1671c0 1038 AliError("the program alimdc was not found");
06c7e392 1039 if (fStopOnError) return kFALSE;
1040 } else {
1041 delete[] path;
1042 }
1043
ac1671c0 1044 AliInfo(Form("converting DATE file %s to root file %s",
1045 dateFileName, rootFileName));
06c7e392 1046
f732bd7d 1047 const char* rawDBFS[2] = { "/tmp/mdc1", "/tmp/mdc2" };
1048 const char* tagDBFS = "/tmp/mdc1/tags";
f732bd7d 1049
1050 // User defined file system locations
1051 if (gSystem->Getenv("ALIMDC_RAWDB1"))
1052 rawDBFS[0] = gSystem->Getenv("ALIMDC_RAWDB1");
1053 if (gSystem->Getenv("ALIMDC_RAWDB2"))
1054 rawDBFS[1] = gSystem->Getenv("ALIMDC_RAWDB2");
1055 if (gSystem->Getenv("ALIMDC_TAGDB"))
1056 tagDBFS = gSystem->Getenv("ALIMDC_TAGDB");
f732bd7d 1057
1058 gSystem->Exec(Form("rm -rf %s",rawDBFS[0]));
1059 gSystem->Exec(Form("rm -rf %s",rawDBFS[1]));
1060 gSystem->Exec(Form("rm -rf %s",tagDBFS));
f732bd7d 1061
1062 gSystem->Exec(Form("mkdir %s",rawDBFS[0]));
1063 gSystem->Exec(Form("mkdir %s",rawDBFS[1]));
1064 gSystem->Exec(Form("mkdir %s",tagDBFS));
f732bd7d 1065
1066 Int_t result = gSystem->Exec(Form("alimdc %d %d %d %d %s",
1067 kDBSize, kTagDBSize, kFilter, kCompression, dateFileName));
1068 gSystem->Exec(Form("mv %s/*.root %s", rawDBFS[0], rootFileName));
1069
1070 gSystem->Exec(Form("rm -rf %s",rawDBFS[0]));
1071 gSystem->Exec(Form("rm -rf %s",rawDBFS[1]));
1072 gSystem->Exec(Form("rm -rf %s",tagDBFS));
06c7e392 1073
1074 return (result == 0);
0421c3d1 1075}
1076
85a5290f 1077
1078//_____________________________________________________________________________
06c7e392 1079AliRunLoader* AliSimulation::LoadRun(const char* mode) const
95601147 1080{
1081// delete existing run loaders, open a new one and load gAlice
1082
1083 while (AliRunLoader::GetRunLoader()) delete AliRunLoader::GetRunLoader();
1084 AliRunLoader* runLoader =
1085 AliRunLoader::Open(fGAliceFileName.Data(),
06c7e392 1086 AliConfig::GetDefaultEventFolderName(), mode);
95601147 1087 if (!runLoader) {
ac1671c0 1088 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
95601147 1089 return NULL;
1090 }
1091 runLoader->LoadgAlice();
1092 gAlice = runLoader->GetAliRun();
1093 if (!gAlice) {
ac1671c0 1094 AliError(Form("no gAlice object found in file %s",
1095 fGAliceFileName.Data()));
95601147 1096 return NULL;
1097 }
1098 return runLoader;
1099}
1100
1101//_____________________________________________________________________________
05526d44 1102Int_t AliSimulation::GetNSignalPerBkgrd(Int_t nEvents) const
1103{
1104// get or calculate the number of signal events per background event
1105
1106 if (!fBkgrdFileNames) return 1;
1107 Int_t nBkgrdFiles = fBkgrdFileNames->GetEntriesFast();
1108 if (nBkgrdFiles == 0) return 1;
1109
1110 // get the number of signal events
1111 if (nEvents <= 0) {
1112 AliRunLoader* runLoader =
ca30848f 1113 AliRunLoader::Open(fGAliceFileName.Data(), "SIGNAL");
05526d44 1114 if (!runLoader) return 1;
ca30848f 1115
05526d44 1116 nEvents = runLoader->GetNumberOfEvents();
1117 delete runLoader;
1118 }
1119
1120 Int_t result = 0;
1121 for (Int_t iBkgrdFile = 0; iBkgrdFile < nBkgrdFiles; iBkgrdFile++) {
1122 // get the number of background events
1123 const char* fileName = ((TObjString*)
1124 (fBkgrdFileNames->At(iBkgrdFile)))->GetName();
ca30848f 1125 AliRunLoader* runLoader =
05526d44 1126 AliRunLoader::Open(fileName, "BKGRD");
1127 if (!runLoader) continue;
1128 Int_t nBkgrdEvents = runLoader->GetNumberOfEvents();
1129 delete runLoader;
ca30848f 1130
05526d44 1131 // get or calculate the number of signal per background events
1132 Int_t nSignalPerBkgrd = fBkgrdFileNames->At(iBkgrdFile)->GetUniqueID();
1133 if (nSignalPerBkgrd <= 0) {
1134 nSignalPerBkgrd = (nEvents-1) / nBkgrdEvents + 1;
1135 } else if (result && (result != nSignalPerBkgrd)) {
ac1671c0 1136 AliInfo(Form("the number of signal events per background event "
1137 "will be changed from %d to %d for stream %d",
1138 nSignalPerBkgrd, result, iBkgrdFile+1));
05526d44 1139 nSignalPerBkgrd = result;
1140 }
1141
1142 if (!result) result = nSignalPerBkgrd;
1143 if (nSignalPerBkgrd * nBkgrdEvents < nEvents) {
ac1671c0 1144 AliWarning(Form("not enough background events (%d) for %d signal events "
1145 "using %d signal per background events for stream %d",
1146 nBkgrdEvents, nEvents, nSignalPerBkgrd, iBkgrdFile+1));
05526d44 1147 }
1148 }
1149
1150 return result;
1151}
1152
1153//_____________________________________________________________________________
85a5290f 1154Bool_t AliSimulation::IsSelected(TString detName, TString& detectors) const
1155{
1156// check whether detName is contained in detectors
1157// if yes, it is removed from detectors
1158
1159 // check if all detectors are selected
1160 if ((detectors.CompareTo("ALL") == 0) ||
1161 detectors.BeginsWith("ALL ") ||
1162 detectors.EndsWith(" ALL") ||
1163 detectors.Contains(" ALL ")) {
1164 detectors = "ALL";
1165 return kTRUE;
1166 }
1167
1168 // search for the given detector
1169 Bool_t result = kFALSE;
1170 if ((detectors.CompareTo(detName) == 0) ||
1171 detectors.BeginsWith(detName+" ") ||
1172 detectors.EndsWith(" "+detName) ||
1173 detectors.Contains(" "+detName+" ")) {
1174 detectors.ReplaceAll(detName, "");
1175 result = kTRUE;
1176 }
1177
1178 // clean up the detectors string
1179 while (detectors.Contains(" ")) detectors.ReplaceAll(" ", " ");
1180 while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
1181 while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
1182
1183 return result;
1184}
ca30848f 1185
1186Bool_t AliSimulation::ConvertRaw2SDigits(const char* rawDirectory, const char* esdFileName)
1187{
1188//
1189// Steering routine to convert raw data in directory rawDirectory/ to fake SDigits.
1190// These can be used for embedding of MC tracks into RAW data using the standard
1191// merging procedure.
1192//
1193// If an ESD file is given the reconstructed vertex is taken from it and stored in the event header.
1194//
1195 if (!gAlice) {
1196 AliError("no gAlice object. Restart aliroot and try again.");
1197 return kFALSE;
1198 }
1199 if (gAlice->Modules()->GetEntries() > 0) {
1200 AliError("gAlice was already run. Restart aliroot and try again.");
1201 return kFALSE;
1202 }
1203
1204 AliInfo(Form("initializing gAlice with config file %s",fConfigFileName.Data()));
1205 StdoutToAliInfo(StderrToAliError(gAlice->Init(fConfigFileName.Data());););
1206//
1207// Initialize CDB
1208 InitCDBStorage();
1209 AliCDBManager* man = AliCDBManager::Instance();
1210 man->SetRun(0); // Should this come from rawdata header ?
1211
1212 Int_t iDet;
1213 //
1214 // Get the runloader
1215 AliRunLoader* runLoader = gAlice->GetRunLoader();
1216 //
1217 // Open esd file if available
1218 TFile* esdFile = TFile::Open(esdFileName);
1219 Bool_t esdOK = (esdFile != 0);
1220 AliESD* esd = new AliESD;
1221 TTree* treeESD = 0;
1222 if (esdOK) {
1223 treeESD = (TTree*) esdFile->Get("esdTree");
1224 if (!treeESD) {
1225 AliWarning("No ESD tree found");
1226 esdOK = kFALSE;
1227 } else {
1228 treeESD->SetBranchAddress("ESD", &esd);
1229 }
1230 }
1231 //
1232 // Create the RawReader
1233 AliRawReaderFile* rawReader = new AliRawReaderFile(rawDirectory);
1234 //
1235 // Get list of detectors
1236 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1237 //
1238 // Get Header
1239 AliHeader* header = runLoader->GetHeader();
1240 //
1241 // Event loop
1242 Int_t nev = 0;
1243 while(kTRUE) {
1244 if (!(rawReader->NextEvent())) break;
1245 //
1246 // Detector loop
1247 for (iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1248 AliModule* det = (AliModule*) detArray->At(iDet);
1249 AliInfo(Form("Calling Raw2SDigits for %s\n", det->GetName()));
1250 det->Raw2SDigits(rawReader);
1251 rawReader->Reset();
1252 } // detectors
1253
1254 //
1255 // If ESD information available obtain reconstructed vertex and store in header.
1256 if (esdOK) {
1257 treeESD->GetEvent(nev);
1258 const AliESDVertex* esdVertex = esd->GetPrimaryVertex();
1259 Double_t position[3];
1260 esdVertex->GetXYZ(position);
1261 AliGenEventHeader* mcHeader = new AliGenEventHeader("ESD");
1262 TArrayF mcV;
1263 mcV.Set(3);
1264 for (Int_t i = 0; i < 3; i++) mcV[i] = position[i];
1265 mcHeader->SetPrimaryVertex(mcV);
1266 header->Reset(0,nev);
1267 header->SetGenEventHeader(mcHeader);
1268 printf("***** Saved vertex %f %f %f \n", position[0], position[1], position[2]);
1269 }
1270 nev++;
1271//
1272// Finish the event
1273 runLoader->TreeE()->Fill();
1274 runLoader->SetNextEvent();
1275 } // events
1276
1277 delete rawReader;
1278//
1279// Finish the run
1280 runLoader->CdGAFile();
1281 runLoader->WriteHeader("OVERWRITE");
1282 runLoader->WriteRunLoader();
1283
1284 return kTRUE;
1285}