1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
18 ///////////////////////////////////////////////////////////////////////////////
20 // class for running generation, simulation and digitization //
22 // Hits, sdigits and digits are created for all detectors by typing: //
24 // AliSimulation sim; //
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 //
31 // sim.SetNumberOfEvents(n); //
33 // The name of the configuration file can be passed as argument to the //
34 // AliSimulation constructor or can be specified by //
36 // sim.SetConfigFile("..."); //
38 // The generation of particles and the simulation of detector hits can be //
39 // switched on or off by //
41 // sim.SetRunGeneration(kTRUE); // generation of primary particles //
42 // sim.SetRunSimulation(kFALSE); // but no tracking //
44 // For which detectors sdigits and digits will be created, can be steered //
47 // sim.SetMakeSDigits("ALL"); // make sdigits for all detectors //
48 // sim.SetMakeDigits("ITS TPC"); // make digits only for ITS and TPC //
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. //
55 // The creation of digits from hits instead of from sdigits can be selected //
58 // sim.SetMakeDigitsFromHits("TRD"); //
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. //
64 // Background events can be merged by calling //
66 // sim.MergeWith("background/galice.root", 2); //
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. //
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. //
75 // The output of raw data can be switched on by calling //
77 // sim.SetWriteRawData("MUON"); // write raw data for MUON //
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 //
88 // The methods RunSimulation, RunSDigitization, RunDigitization, //
89 // RunHitsDigitization and WriteRawData can be used to run only parts of //
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. //
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 //
98 // sim.SetEventsPerFile("PHOS", "Reconstructed Points", 3); //
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. //
106 ///////////////////////////////////////////////////////////////////////////////
108 #include <TObjString.h>
109 #include <TStopwatch.h>
113 #include "AliDigitizer.h"
114 #include "AliGenerator.h"
115 #include "AliModule.h"
117 #include "AliRunDigitizer.h"
118 #include "AliRunLoader.h"
119 #include "AliSimulation.h"
120 #include "AliVertexGenFile.h"
122 ClassImp(AliSimulation)
125 //_____________________________________________________________________________
126 AliSimulation::AliSimulation(const char* configFileName,
127 const char* name, const char* title) :
130 fRunGeneration(kTRUE),
131 fRunSimulation(kTRUE),
134 fMakeDigitsFromHits(""),
136 fRawDataFileName(""),
137 fDeleteIntermediateFiles(kFALSE),
138 fStopOnError(kFALSE),
141 fConfigFileName(configFileName),
142 fGAliceFileName("galice.root"),
144 fBkgrdFileNames(NULL),
145 fUseBkgrdVertex(kTRUE),
146 fRegionOfInterest(kFALSE)
148 // create simulation object with default parameters
150 SetGAliceFile("galice.root");
153 //_____________________________________________________________________________
154 AliSimulation::AliSimulation(const AliSimulation& sim) :
157 fRunGeneration(sim.fRunGeneration),
158 fRunSimulation(sim.fRunSimulation),
159 fMakeSDigits(sim.fMakeSDigits),
160 fMakeDigits(sim.fMakeDigits),
161 fMakeDigitsFromHits(sim.fMakeDigitsFromHits),
162 fWriteRawData(sim.fWriteRawData),
163 fRawDataFileName(""),
164 fDeleteIntermediateFiles(kFALSE),
165 fStopOnError(sim.fStopOnError),
167 fNEvents(sim.fNEvents),
168 fConfigFileName(sim.fConfigFileName),
169 fGAliceFileName(sim.fGAliceFileName),
171 fBkgrdFileNames(NULL),
172 fUseBkgrdVertex(sim.fUseBkgrdVertex),
173 fRegionOfInterest(sim.fRegionOfInterest)
177 for (Int_t i = 0; i < sim.fEventsPerFile.GetEntriesFast(); i++) {
178 if (!sim.fEventsPerFile[i]) continue;
179 fEventsPerFile.Add(sim.fEventsPerFile[i]->Clone());
182 fBkgrdFileNames = new TObjArray;
183 for (Int_t i = 0; i < sim.fBkgrdFileNames->GetEntriesFast(); i++) {
184 if (!sim.fBkgrdFileNames->At(i)) continue;
185 fBkgrdFileNames->Add(sim.fBkgrdFileNames->At(i)->Clone());
189 //_____________________________________________________________________________
190 AliSimulation& AliSimulation::operator = (const AliSimulation& sim)
192 // assignment operator
194 this->~AliSimulation();
195 new(this) AliSimulation(sim);
199 //_____________________________________________________________________________
200 AliSimulation::~AliSimulation()
204 fEventsPerFile.Delete();
206 if (fBkgrdFileNames) {
207 fBkgrdFileNames->Delete();
208 delete fBkgrdFileNames;
213 //_____________________________________________________________________________
214 void AliSimulation::SetNumberOfEvents(Int_t nEvents)
216 // set the number of events for one run
221 //_____________________________________________________________________________
222 void AliSimulation::SetConfigFile(const char* fileName)
224 // set the name of the config file
226 fConfigFileName = fileName;
229 //_____________________________________________________________________________
230 void AliSimulation::SetGAliceFile(const char* fileName)
232 // set the name of the galice file
233 // the path is converted to an absolute one if it is relative
235 fGAliceFileName = fileName;
236 if (!gSystem->IsAbsoluteFileName(fGAliceFileName)) {
237 char* absFileName = gSystem->ConcatFileName(gSystem->WorkingDirectory(),
239 fGAliceFileName = absFileName;
240 delete[] absFileName;
243 AliDebug(2, Form("galice file name set to %s", fileName));
246 //_____________________________________________________________________________
247 void AliSimulation::SetEventsPerFile(const char* detector, const char* type,
250 // set the number of events per file for the given detector and data type
251 // ("Hits", "Summable Digits", "Digits", "Reconstructed Points" or "Tracks")
253 TNamed* obj = new TNamed(detector, type);
254 obj->SetUniqueID(nEvents);
255 fEventsPerFile.Add(obj);
258 //_____________________________________________________________________________
259 void AliSimulation::MergeWith(const char* fileName, Int_t nSignalPerBkgrd)
261 // add a file with background events for merging
263 TObjString* fileNameStr = new TObjString(fileName);
264 fileNameStr->SetUniqueID(nSignalPerBkgrd);
265 if (!fBkgrdFileNames) fBkgrdFileNames = new TObjArray;
266 fBkgrdFileNames->Add(fileNameStr);
270 //_____________________________________________________________________________
271 Bool_t AliSimulation::Run(Int_t nEvents)
273 // run the generation, simulation and digitization
275 if (nEvents > 0) fNEvents = nEvents;
277 // generation and simulation -> hits
278 if (fRunGeneration) {
279 if (!RunSimulation()) if (fStopOnError) return kFALSE;
282 // hits -> summable digits
283 if (!fMakeSDigits.IsNull()) {
284 if (!RunSDigitization(fMakeSDigits)) if (fStopOnError) return kFALSE;
287 // summable digits -> digits
288 if (!fMakeDigits.IsNull()) {
289 if (!RunDigitization(fMakeDigits, fMakeDigitsFromHits)) {
290 if (fStopOnError) return kFALSE;
295 if (!fMakeDigitsFromHits.IsNull()) {
296 if (fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
297 AliWarning(Form("Merging and direct creation of digits from hits "
298 "was selected for some detectors. "
299 "No merging will be done for the following detectors: %s",
300 fMakeDigitsFromHits.Data()));
302 if (!RunHitsDigitization(fMakeDigitsFromHits)) {
303 if (fStopOnError) return kFALSE;
307 // digits -> raw data
308 if (!fWriteRawData.IsNull()) {
309 if (!WriteRawData(fWriteRawData, fRawDataFileName,
310 fDeleteIntermediateFiles)) {
311 if (fStopOnError) return kFALSE;
318 //_____________________________________________________________________________
319 Bool_t AliSimulation::RunSimulation(Int_t nEvents)
321 // run the generation and simulation
323 TStopwatch stopwatch;
327 AliError("no gAlice object. Restart aliroot and try again.");
330 if (gAlice->Modules()->GetEntries() > 0) {
331 AliError("gAlice was already run. Restart aliroot and try again.");
335 AliInfo(Form("initializing gAlice with config file %s",
336 fConfigFileName.Data()));
337 StdoutToAliInfo(StderrToAliError(
338 gAlice->Init(fConfigFileName.Data());
340 AliRunLoader* runLoader = gAlice->GetRunLoader();
342 AliError(Form("gAlice has no run loader object. "
343 "Check your config file: %s", fConfigFileName.Data()));
346 SetGAliceFile(runLoader->GetFileName());
348 if (!gAlice->Generator()) {
349 AliError(Form("gAlice has no generator object. "
350 "Check your config file: %s", fConfigFileName.Data()));
353 if (nEvents <= 0) nEvents = fNEvents;
355 // get vertex from background file in case of merging
356 if (fUseBkgrdVertex &&
357 fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
358 Int_t signalPerBkgrd = GetNSignalPerBkgrd(nEvents);
359 const char* fileName = ((TObjString*)
360 (fBkgrdFileNames->At(0)))->GetName();
361 AliInfo(Form("The vertex will be taken from the background "
362 "file %s with nSignalPerBackground = %d",
363 fileName, signalPerBkgrd));
364 AliVertexGenFile* vtxGen = new AliVertexGenFile(fileName, signalPerBkgrd);
365 gAlice->Generator()->SetVertexGenerator(vtxGen);
368 if (!fRunSimulation) {
369 gAlice->Generator()->SetTrackingFlag(0);
372 // set the number of events per file for given detectors and data types
373 for (Int_t i = 0; i < fEventsPerFile.GetEntriesFast(); i++) {
374 if (!fEventsPerFile[i]) continue;
375 const char* detName = fEventsPerFile[i]->GetName();
376 const char* typeName = fEventsPerFile[i]->GetTitle();
377 TString loaderName(detName);
378 loaderName += "Loader";
379 AliLoader* loader = runLoader->GetLoader(loaderName);
381 AliError(Form("RunSimulation", "no loader for %s found\n"
382 "Number of events per file not set for %s %s",
383 detName, typeName, detName));
386 AliDataLoader* dataLoader =
387 loader->GetDataLoader(typeName);
389 AliError(Form("no data loader for %s found\n"
390 "Number of events per file not set for %s %s",
391 typeName, detName, typeName));
394 dataLoader->SetNumberOfEventsPerFile(fEventsPerFile[i]->GetUniqueID());
395 AliDebug(1, Form("number of events per file set to %d for %s %s",
396 fEventsPerFile[i]->GetUniqueID(), detName, typeName));
399 AliInfo("running gAlice");
400 StdoutToAliInfo(StderrToAliError(
401 gAlice->Run(nEvents);
406 AliInfo("execution time:");
407 StdoutToAliInfo(stopwatch.Print(););
412 //_____________________________________________________________________________
413 Bool_t AliSimulation::RunSDigitization(const char* detectors)
415 // run the digitization and produce summable digits
417 TStopwatch stopwatch;
420 AliRunLoader* runLoader = LoadRun();
421 if (!runLoader) return kFALSE;
423 TString detStr = detectors;
424 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
425 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
426 AliModule* det = (AliModule*) detArray->At(iDet);
427 if (!det || !det->IsActive()) continue;
428 if (IsSelected(det->GetName(), detStr)) {
429 AliInfo(Form("creating summable digits for %s", det->GetName()));
430 TStopwatch stopwatchDet;
431 stopwatchDet.Start();
433 AliInfo(Form("execution time for %s:", det->GetName()));
434 StdoutToAliInfo(stopwatchDet.Print(););
438 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
439 AliError(Form("the following detectors were not found: %s",
441 if (fStopOnError) return kFALSE;
446 AliInfo("execution time:");
447 StdoutToAliInfo(stopwatch.Print(););
453 //_____________________________________________________________________________
454 Bool_t AliSimulation::RunDigitization(const char* detectors,
455 const char* excludeDetectors)
457 // run the digitization and produce digits from sdigits
459 TStopwatch stopwatch;
462 while (AliRunLoader::GetRunLoader()) delete AliRunLoader::GetRunLoader();
463 if (gAlice) delete gAlice;
467 if (fBkgrdFileNames) nStreams = fBkgrdFileNames->GetEntriesFast() + 1;
468 Int_t signalPerBkgrd = GetNSignalPerBkgrd();
469 AliRunDigitizer* manager = new AliRunDigitizer(nStreams, signalPerBkgrd);
470 manager->SetInputStream(0, fGAliceFileName.Data());
471 for (Int_t iStream = 1; iStream < nStreams; iStream++) {
472 const char* fileName = ((TObjString*)
473 (fBkgrdFileNames->At(iStream-1)))->GetName();
474 manager->SetInputStream(iStream, fileName);
477 TString detStr = detectors;
478 TString detExcl = excludeDetectors;
479 manager->GetInputStream(0)->ImportgAlice();
480 AliRunLoader* runLoader =
481 AliRunLoader::GetRunLoader(manager->GetInputStream(0)->GetFolderName());
482 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
483 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
484 AliModule* det = (AliModule*) detArray->At(iDet);
485 if (!det || !det->IsActive()) continue;
486 if (IsSelected(det->GetName(), detStr) &&
487 !IsSelected(det->GetName(), detExcl)) {
488 AliDigitizer* digitizer = det->CreateDigitizer(manager);
490 AliError(Form("no digitizer for %s", det->GetName()));
491 if (fStopOnError) return kFALSE;
493 digitizer->SetRegionOfInterest(fRegionOfInterest);
498 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
499 AliError(Form("the following detectors were not found: %s",
501 if (fStopOnError) return kFALSE;
504 if (!manager->GetListOfTasks()->IsEmpty()) {
505 AliInfo("executing digitization");
511 AliInfo("execution time:");
512 StdoutToAliInfo(stopwatch.Print(););
517 //_____________________________________________________________________________
518 Bool_t AliSimulation::RunHitsDigitization(const char* detectors)
520 // run the digitization and produce digits from hits
522 TStopwatch stopwatch;
525 AliRunLoader* runLoader = LoadRun();
526 if (!runLoader) return kFALSE;
528 TString detStr = detectors;
529 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
530 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
531 AliModule* det = (AliModule*) detArray->At(iDet);
532 if (!det || !det->IsActive()) continue;
533 if (IsSelected(det->GetName(), detStr)) {
534 AliInfo(Form("creating digits from hits for %s", det->GetName()));
539 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
540 AliError(Form("the following detectors were not found: %s",
542 if (fStopOnError) return kFALSE;
547 AliInfo("execution time:");
548 StdoutToAliInfo(stopwatch.Print(););
553 //_____________________________________________________________________________
554 Bool_t AliSimulation::WriteRawData(const char* detectors,
555 const char* fileName,
556 Bool_t deleteIntermediateFiles)
558 // convert the digits to raw data
559 // First DDL raw data files for the given detectors are created.
560 // If a file name is given, the DDL files are then converted to a DATE file.
561 // If deleteIntermediateFiles is true, the DDL raw files are deleted
563 // If the file name has the extension ".root", the DATE file is converted
565 // If deleteIntermediateFiles is true, the DATE file is deleted afterwards.
567 TStopwatch stopwatch;
570 if (!WriteRawFiles(detectors)) {
571 if (fStopOnError) return kFALSE;
574 TString dateFileName(fileName);
575 if (!dateFileName.IsNull()) {
576 Bool_t rootOutput = dateFileName.EndsWith(".root");
577 if (rootOutput) dateFileName += ".date";
578 if (!ConvertRawFilesToDate(dateFileName)) {
579 if (fStopOnError) return kFALSE;
581 if (deleteIntermediateFiles) {
582 AliRunLoader* runLoader = LoadRun("READ");
583 if (runLoader) for (Int_t iEvent = 0;
584 iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
586 sprintf(command, "rm -r raw%d", iEvent);
587 gSystem->Exec(command);
592 if (!ConvertDateToRoot(dateFileName, fileName)) {
593 if (fStopOnError) return kFALSE;
595 if (deleteIntermediateFiles) {
596 gSystem->Unlink(dateFileName);
601 AliInfo("execution time:");
602 StdoutToAliInfo(stopwatch.Print(););
607 //_____________________________________________________________________________
608 Bool_t AliSimulation::WriteRawFiles(const char* detectors)
610 // convert the digits to raw data DDL files
612 AliRunLoader* runLoader = LoadRun("READ");
613 if (!runLoader) return kFALSE;
615 // write raw data to DDL files
616 for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
617 AliInfo(Form("processing event %d", iEvent));
618 runLoader->GetEvent(iEvent);
619 TString baseDir = gSystem->WorkingDirectory();
621 sprintf(dirName, "raw%d", iEvent);
622 gSystem->MakeDirectory(dirName);
623 if (!gSystem->ChangeDirectory(dirName)) {
624 AliError(Form("couldn't change to directory %s", dirName));
625 if (fStopOnError) return kFALSE; else continue;
628 TString detStr = detectors;
629 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
630 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
631 AliModule* det = (AliModule*) detArray->At(iDet);
632 if (!det || !det->IsActive()) continue;
633 if (IsSelected(det->GetName(), detStr)) {
634 AliInfo(Form("creating raw data from digits for %s", det->GetName()));
639 gSystem->ChangeDirectory(baseDir);
640 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
641 AliError(Form("the following detectors were not found: %s",
643 if (fStopOnError) return kFALSE;
651 //_____________________________________________________________________________
652 Bool_t AliSimulation::ConvertRawFilesToDate(const char* dateFileName)
654 // convert raw data DDL files to a DATE file with the program "dateStream"
657 const Int_t kNDetectors = 17;
658 const char* kDetectors[kNDetectors] = {"TPC", "ITSSPD", "ITSSDD", "ITSSSD",
659 "TRD", "TOF", "PHOS", "RICH",
660 "EMCAL", "MUON", "MUTR", "ZDC",
661 "PMD", "START", "VZERO", "CRT",
663 const Int_t kDetectorDDLs[kNDetectors] = {216, 20, 12, 16,
668 const Float_t kDetectorLDCs[kNDetectors] = {46, 2, 2, 1,
674 char* path = gSystem->Which(gSystem->Getenv("PATH"), "dateStream");
676 AliError("the program dateStream was not found");
677 if (fStopOnError) return kFALSE;
682 AliRunLoader* runLoader = LoadRun("READ");
683 if (!runLoader) return kFALSE;
685 AliInfo(Form("converting raw data DDL files to DATE file %s", dateFileName));
687 sprintf(command, "dateStream -o %s -# %d -C",
688 dateFileName, runLoader->GetNumberOfEvents());
689 FILE* pipe = gSystem->OpenPipe(command, "w");
691 for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
692 fprintf(pipe, "GDC\n");
696 // loop over detectors and DDLs
697 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
698 for (Int_t iDDL = 0; iDDL < kDetectorDDLs[iDet]; iDDL++) {
700 Int_t ddlID = 0x100*iDet + iDDL;
701 Int_t ldcID = Int_t(ldc + 0.0001);
702 ldc += kDetectorLDCs[iDet] / kDetectorDDLs[iDet];
704 char rawFileName[256];
705 sprintf(rawFileName, "raw%d/%s_%d.ddl",
706 iEvent, kDetectors[iDet], ddlID);
708 // check existence and size of raw data file
709 FILE* file = fopen(rawFileName, "rb");
711 fseek(file, 0, SEEK_END);
712 unsigned long size = ftell(file);
716 if (ldcID != prevLDC) {
717 fprintf(pipe, " LDC Id %d\n", ldcID);
720 fprintf(pipe, " Equipment Id %d Payload %s\n", ddlID, rawFileName);
725 Int_t result = gSystem->ClosePipe(pipe);
728 return (result == 0);
731 //_____________________________________________________________________________
732 Bool_t AliSimulation::ConvertDateToRoot(const char* dateFileName,
733 const char* rootFileName)
735 // convert a DATE file to a root file with the program "alimdc"
738 const Int_t kDBSize = 1000000000;
739 const Int_t kTagDBSize = 1000000000;
740 const Bool_t kFilter = kFALSE;
741 const Int_t kCompression = 1;
743 char* path = gSystem->Which(gSystem->Getenv("PATH"), "alimdc");
745 AliError("the program alimdc was not found");
746 if (fStopOnError) return kFALSE;
751 AliInfo(Form("converting DATE file %s to root file %s",
752 dateFileName, rootFileName));
754 gSystem->Exec("rm -rf /tmp/mdc1");
755 gSystem->Exec("rm -rf /tmp/mdc2");
757 gSystem->Exec("mkdir /tmp/mdc1");
758 gSystem->Exec("mkdir /tmp/mdc2");
761 sprintf(command, "alimdc %d %d %d %d %s",
762 kDBSize, kTagDBSize, kFilter, kCompression, dateFileName);
763 Int_t result = gSystem->Exec(command);
764 sprintf(command, "mv /tmp/mdc1/*.root %s", rootFileName);
765 gSystem->Exec(command);
766 gSystem->Exec("rm -rf /tmp/mdc1");
767 gSystem->Exec("rm -rf /tmp/mdc2");
769 return (result == 0);
773 //_____________________________________________________________________________
774 AliRunLoader* AliSimulation::LoadRun(const char* mode) const
776 // delete existing run loaders, open a new one and load gAlice
778 while (AliRunLoader::GetRunLoader()) delete AliRunLoader::GetRunLoader();
779 AliRunLoader* runLoader =
780 AliRunLoader::Open(fGAliceFileName.Data(),
781 AliConfig::GetDefaultEventFolderName(), mode);
783 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
786 runLoader->LoadgAlice();
787 gAlice = runLoader->GetAliRun();
789 AliError(Form("no gAlice object found in file %s",
790 fGAliceFileName.Data()));
796 //_____________________________________________________________________________
797 Int_t AliSimulation::GetNSignalPerBkgrd(Int_t nEvents) const
799 // get or calculate the number of signal events per background event
801 if (!fBkgrdFileNames) return 1;
802 Int_t nBkgrdFiles = fBkgrdFileNames->GetEntriesFast();
803 if (nBkgrdFiles == 0) return 1;
805 // get the number of signal events
807 AliRunLoader* runLoader =
808 AliRunLoader::Open(fGAliceFileName.Data(), "SIGNAL");
809 if (!runLoader) return 1;
810 nEvents = runLoader->GetNumberOfEvents();
815 for (Int_t iBkgrdFile = 0; iBkgrdFile < nBkgrdFiles; iBkgrdFile++) {
816 // get the number of background events
817 const char* fileName = ((TObjString*)
818 (fBkgrdFileNames->At(iBkgrdFile)))->GetName();
819 AliRunLoader* runLoader =
820 AliRunLoader::Open(fileName, "BKGRD");
821 if (!runLoader) continue;
822 Int_t nBkgrdEvents = runLoader->GetNumberOfEvents();
825 // get or calculate the number of signal per background events
826 Int_t nSignalPerBkgrd = fBkgrdFileNames->At(iBkgrdFile)->GetUniqueID();
827 if (nSignalPerBkgrd <= 0) {
828 nSignalPerBkgrd = (nEvents-1) / nBkgrdEvents + 1;
829 } else if (result && (result != nSignalPerBkgrd)) {
830 AliInfo(Form("the number of signal events per background event "
831 "will be changed from %d to %d for stream %d",
832 nSignalPerBkgrd, result, iBkgrdFile+1));
833 nSignalPerBkgrd = result;
836 if (!result) result = nSignalPerBkgrd;
837 if (nSignalPerBkgrd * nBkgrdEvents < nEvents) {
838 AliWarning(Form("not enough background events (%d) for %d signal events "
839 "using %d signal per background events for stream %d",
840 nBkgrdEvents, nEvents, nSignalPerBkgrd, iBkgrdFile+1));
847 //_____________________________________________________________________________
848 Bool_t AliSimulation::IsSelected(TString detName, TString& detectors) const
850 // check whether detName is contained in detectors
851 // if yes, it is removed from detectors
853 // check if all detectors are selected
854 if ((detectors.CompareTo("ALL") == 0) ||
855 detectors.BeginsWith("ALL ") ||
856 detectors.EndsWith(" ALL") ||
857 detectors.Contains(" ALL ")) {
862 // search for the given detector
863 Bool_t result = kFALSE;
864 if ((detectors.CompareTo(detName) == 0) ||
865 detectors.BeginsWith(detName+" ") ||
866 detectors.EndsWith(" "+detName) ||
867 detectors.Contains(" "+detName+" ")) {
868 detectors.ReplaceAll(detName, "");
872 // clean up the detectors string
873 while (detectors.Contains(" ")) detectors.ReplaceAll(" ", " ");
874 while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
875 while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);