// //
// sim.SetNumberOfEvents(n); //
// //
-// The name of the configuration file can be specified by //
+// The name of the configuration file can be passed as argument to the //
+// AliSimulation constructor or can be specified by //
// //
// sim.SetConfigFile("..."); //
// //
// this feature is not available for all detectors and that merging is not //
// possible, when digits are created directly from hits. //
// //
-// Backgound events can be merged by calling //
+// Background events can be merged by calling //
// //
// sim.MergeWith("background/galice.root", 2); //
// //
// The first argument is the file name of the background galice file. The //
// second argument is the number of signal events per background event. //
-// The default value for this is 1. MergeWith can be called several times //
-// to merge more than two event streams. It is assumed that the sdigits //
-// were already produced for the background events. //
+// By default this number is calculated from the number of available //
+// background events. MergeWith can be called several times to merge more //
+// than two event streams. It is assumed that the sdigits were already //
+// produced for the background events. //
+// //
+// The output of raw data can be switched on by calling //
+// //
+// sim.SetWriteRawData("MUON"); // write raw data for MUON //
+// //
+// The default output format of the raw data are DDL files. They are //
+// converted to a DATE file, if a file name is given as second argument. //
+// For this conversion the program "dateStream" is required. If the file //
+// name has the extension ".root", the DATE file is converted to a root //
+// file. The program "alimdc" is used for this purpose. For the conversion //
+// to DATE and root format the two conversion programs have to be installed. //
+// Only the raw data in the final format is kept if the third argument is //
+// kTRUE. //
+// //
+// The methods RunSimulation, RunSDigitization, RunDigitization, //
+// RunHitsDigitization and WriteRawData can be used to run only parts of //
+// the full simulation chain. The creation of raw data DDL files and their //
+// conversion to the DATE or root format can be run directly by calling //
+// the methods WriteRawFiles, ConvertRawFilesToDate and ConvertDateToRoot. //
+// //
+// The default number of events per file, which is usually set in the //
+// config file, can be changed for individual detectors and data types //
+// by calling //
+// //
+// sim.SetEventsPerFile("PHOS", "Reconstructed Points", 3); //
+// //
+// The first argument is the detector, the second one the data type and the //
+// last one the number of events per file. Valid data types are "Hits", //
+// "Summable Digits", "Digits", "Reconstructed Points" and "Tracks". //
+// The number of events per file has to be set before the simulation of //
+// hits. Otherwise it has no effect. //
// //
///////////////////////////////////////////////////////////////////////////////
+#include <TObjString.h>
+#include <TStopwatch.h>
+#include <TSystem.h>
-#include "AliSimulation.h"
-#include "AliRunLoader.h"
-#include "AliRun.h"
-#include "AliModule.h"
+#include "AliLog.h"
+#include "AliDigitizer.h"
#include "AliGenerator.h"
+#include "AliModule.h"
+#include "AliRun.h"
#include "AliRunDigitizer.h"
-#include "AliDigitizer.h"
-#include <TObjString.h>
-
+#include "AliRunLoader.h"
+#include "AliSimulation.h"
+#include "AliVertexGenFile.h"
ClassImp(AliSimulation)
//_____________________________________________________________________________
-AliSimulation::AliSimulation(const char* name, const char* title) :
- TNamed(name, title)
+AliSimulation::AliSimulation(const char* configFileName,
+ const char* name, const char* title) :
+ TNamed(name, title),
+
+ fRunGeneration(kTRUE),
+ fRunSimulation(kTRUE),
+ fMakeSDigits("ALL"),
+ fMakeDigits("ALL"),
+ fMakeDigitsFromHits(""),
+ fWriteRawData(""),
+ fRawDataFileName(""),
+ fDeleteIntermediateFiles(kFALSE),
+ fStopOnError(kFALSE),
+
+ fNEvents(1),
+ fConfigFileName(configFileName),
+ fGAliceFileName("galice.root"),
+ fEventsPerFile(),
+ fBkgrdFileNames(NULL),
+ fUseBkgrdVertex(kTRUE),
+ fRegionOfInterest(kFALSE)
{
// create simulation object with default parameters
- Init();
+ SetGAliceFile("galice.root");
}
//_____________________________________________________________________________
AliSimulation::AliSimulation(const AliSimulation& sim) :
- TNamed(sim)
+ TNamed(sim),
+
+ fRunGeneration(sim.fRunGeneration),
+ fRunSimulation(sim.fRunSimulation),
+ fMakeSDigits(sim.fMakeSDigits),
+ fMakeDigits(sim.fMakeDigits),
+ fMakeDigitsFromHits(sim.fMakeDigitsFromHits),
+ fWriteRawData(sim.fWriteRawData),
+ fRawDataFileName(""),
+ fDeleteIntermediateFiles(kFALSE),
+ fStopOnError(sim.fStopOnError),
+
+ fNEvents(sim.fNEvents),
+ fConfigFileName(sim.fConfigFileName),
+ fGAliceFileName(sim.fGAliceFileName),
+ fEventsPerFile(),
+ fBkgrdFileNames(NULL),
+ fUseBkgrdVertex(sim.fUseBkgrdVertex),
+ fRegionOfInterest(sim.fRegionOfInterest)
{
// copy constructor
- fRunGeneration = sim.fRunGeneration;
- fRunSimulation = sim.fRunSimulation;
- fMakeSDigits = sim.fMakeSDigits;
- fMakeDigits = sim.fMakeDigits;
- fMakeDigitsFromHits = sim.fMakeDigitsFromHits;
- fStopOnError = sim.fStopOnError;
+ for (Int_t i = 0; i < sim.fEventsPerFile.GetEntriesFast(); i++) {
+ if (!sim.fEventsPerFile[i]) continue;
+ fEventsPerFile.Add(sim.fEventsPerFile[i]->Clone());
+ }
- fNEvents = sim.fNEvents;
- fConfigFileName = sim.fConfigFileName;
- fGAliceFileName = sim.fGAliceFileName;
fBkgrdFileNames = new TObjArray;
for (Int_t i = 0; i < sim.fBkgrdFileNames->GetEntriesFast(); i++) {
if (!sim.fBkgrdFileNames->At(i)) continue;
fBkgrdFileNames->Add(sim.fBkgrdFileNames->At(i)->Clone());
}
-
- fRunLoader = NULL;
}
//_____________________________________________________________________________
{
// clean up
- fBkgrdFileNames->Delete();
- delete fBkgrdFileNames;
-}
-
-//_____________________________________________________________________________
-void AliSimulation::Init()
-{
-// set default parameters
-
- fRunGeneration = kTRUE;
- fRunSimulation = kTRUE;
- fMakeSDigits = "ALL";
- fMakeDigits = "ALL";
- fMakeDigitsFromHits = "";
- fStopOnError = kFALSE;
-
- fNEvents = 1;
- fConfigFileName = "Config.C";
- fGAliceFileName = "galice.root";
- fBkgrdFileNames = new TObjArray;
- fRegionOfInterest = kTRUE;
+ fEventsPerFile.Delete();
- fRunLoader = NULL;
+ if (fBkgrdFileNames) {
+ fBkgrdFileNames->Delete();
+ delete fBkgrdFileNames;
+ }
}
fConfigFileName = fileName;
}
+//_____________________________________________________________________________
+void AliSimulation::SetGAliceFile(const char* fileName)
+{
+// set the name of the galice file
+// the path is converted to an absolute one if it is relative
+
+ fGAliceFileName = fileName;
+ if (!gSystem->IsAbsoluteFileName(fGAliceFileName)) {
+ char* absFileName = gSystem->ConcatFileName(gSystem->WorkingDirectory(),
+ fGAliceFileName);
+ fGAliceFileName = absFileName;
+ delete[] absFileName;
+ }
+
+ AliDebug(2, Form("galice file name set to %s", fileName));
+}
+
+//_____________________________________________________________________________
+void AliSimulation::SetEventsPerFile(const char* detector, const char* type,
+ Int_t nEvents)
+{
+// set the number of events per file for the given detector and data type
+// ("Hits", "Summable Digits", "Digits", "Reconstructed Points" or "Tracks")
+
+ TNamed* obj = new TNamed(detector, type);
+ obj->SetUniqueID(nEvents);
+ fEventsPerFile.Add(obj);
+}
+
//_____________________________________________________________________________
void AliSimulation::MergeWith(const char* fileName, Int_t nSignalPerBkgrd)
{
TObjString* fileNameStr = new TObjString(fileName);
fileNameStr->SetUniqueID(nSignalPerBkgrd);
+ if (!fBkgrdFileNames) fBkgrdFileNames = new TObjArray;
fBkgrdFileNames->Add(fileNameStr);
}
// generation and simulation -> hits
if (fRunGeneration) {
- if (!gAlice) {
- Error("Run", "no gAlice object. Restart aliroot and try again.");
- return kFALSE;
- }
- if (gAlice->Modules()->GetEntries() > 0) {
- Error("Run", "gAlice was already run. Restart aliroot and try again.");
- return kFALSE;
- }
if (!RunSimulation()) if (fStopOnError) return kFALSE;
}
- // reopen the run loader
- if (fRunLoader) delete fRunLoader;
- fRunLoader = AliRunLoader::Open(fGAliceFileName.Data(),AliConfig::fgkDefaultEventFolderName,"UPDATE");
- if (!fRunLoader) {
- Error("Run", "no run loader found in file %s",
- fGAliceFileName.Data());
- return kFALSE;
- }
- fRunLoader->LoadgAlice();
- gAlice = fRunLoader->GetAliRun();
- if (!gAlice) {
- Error("Run", "no gAlice object found in file %s",
- fGAliceFileName.Data());
- return kFALSE;
- }
-
// hits -> summable digits
if (!fMakeSDigits.IsNull()) {
if (!RunSDigitization(fMakeSDigits)) if (fStopOnError) return kFALSE;
// hits -> digits
if (!fMakeDigitsFromHits.IsNull()) {
- if (fBkgrdFileNames->GetEntriesFast() > 0) {
- Warning("Run", "Merging and direct creation of digits from hits "
- "was selected for some detectors. "
- "No merging will be done for the following detectors: %s",
- fMakeDigitsFromHits.Data());
+ if (fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
+ AliWarning(Form("Merging and direct creation of digits from hits "
+ "was selected for some detectors. "
+ "No merging will be done for the following detectors: %s",
+ fMakeDigitsFromHits.Data()));
}
if (!RunHitsDigitization(fMakeDigitsFromHits)) {
if (fStopOnError) return kFALSE;
}
}
+ // digits -> raw data
+ if (!fWriteRawData.IsNull()) {
+ if (!WriteRawData(fWriteRawData, fRawDataFileName,
+ fDeleteIntermediateFiles)) {
+ if (fStopOnError) return kFALSE;
+ }
+ }
+
return kTRUE;
}
//_____________________________________________________________________________
-Bool_t AliSimulation::RunSimulation()
+Bool_t AliSimulation::RunSimulation(Int_t nEvents)
{
// run the generation and simulation
TStopwatch stopwatch;
stopwatch.Start();
- Info("RunSimulation", "initializing gAlice with config file %s",
- fConfigFileName.Data());
- gAlice->Init(fConfigFileName.Data());
- fRunLoader = gAlice->GetRunLoader();
- if (!fRunLoader) {
- Error("RunSimulation", "gAlice has no run loader object. "
- "Check your config file: %s", fConfigFileName.Data());
+ if (!gAlice) {
+ AliError("no gAlice object. Restart aliroot and try again.");
+ return kFALSE;
+ }
+ if (gAlice->Modules()->GetEntries() > 0) {
+ AliError("gAlice was already run. Restart aliroot and try again.");
+ return kFALSE;
+ }
+
+ AliInfo(Form("initializing gAlice with config file %s",
+ fConfigFileName.Data()));
+ StdoutToAliInfo(StderrToAliError(
+ gAlice->Init(fConfigFileName.Data());
+ ););
+ AliRunLoader* runLoader = gAlice->GetRunLoader();
+ if (!runLoader) {
+ AliError(Form("gAlice has no run loader object. "
+ "Check your config file: %s", fConfigFileName.Data()));
+ return kFALSE;
+ }
+ SetGAliceFile(runLoader->GetFileName());
+
+ if (!gAlice->Generator()) {
+ AliError(Form("gAlice has no generator object. "
+ "Check your config file: %s", fConfigFileName.Data()));
return kFALSE;
}
- fGAliceFileName = fRunLoader->GetFileName();
+ if (nEvents <= 0) nEvents = fNEvents;
+
+ // get vertex from background file in case of merging
+ if (fUseBkgrdVertex &&
+ fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
+ Int_t signalPerBkgrd = GetNSignalPerBkgrd(nEvents);
+ const char* fileName = ((TObjString*)
+ (fBkgrdFileNames->At(0)))->GetName();
+ AliInfo(Form("The vertex will be taken from the background "
+ "file %s with nSignalPerBackground = %d",
+ fileName, signalPerBkgrd));
+ AliVertexGenFile* vtxGen = new AliVertexGenFile(fileName, signalPerBkgrd);
+ gAlice->Generator()->SetVertexGenerator(vtxGen);
+ }
if (!fRunSimulation) {
- if (!gAlice->Generator()) {
- Error("RunSimulation", "gAlice has no generator object. "
- "Check your config file: %s", fConfigFileName.Data());
- return kFALSE;
- }
gAlice->Generator()->SetTrackingFlag(0);
}
- Info("RunSimulation", "running gAlice");
- gAlice->Run(fNEvents);
+ // set the number of events per file for given detectors and data types
+ for (Int_t i = 0; i < fEventsPerFile.GetEntriesFast(); i++) {
+ if (!fEventsPerFile[i]) continue;
+ const char* detName = fEventsPerFile[i]->GetName();
+ const char* typeName = fEventsPerFile[i]->GetTitle();
+ TString loaderName(detName);
+ loaderName += "Loader";
+ AliLoader* loader = runLoader->GetLoader(loaderName);
+ if (!loader) {
+ AliError(Form("RunSimulation", "no loader for %s found\n"
+ "Number of events per file not set for %s %s",
+ detName, typeName, detName));
+ continue;
+ }
+ AliDataLoader* dataLoader =
+ loader->GetDataLoader(typeName);
+ if (!dataLoader) {
+ AliError(Form("no data loader for %s found\n"
+ "Number of events per file not set for %s %s",
+ typeName, detName, typeName));
+ continue;
+ }
+ dataLoader->SetNumberOfEventsPerFile(fEventsPerFile[i]->GetUniqueID());
+ AliDebug(1, Form("number of events per file set to %d for %s %s",
+ fEventsPerFile[i]->GetUniqueID(), detName, typeName));
+ }
+
+ AliInfo("running gAlice");
+ StdoutToAliInfo(StderrToAliError(
+ gAlice->Run(nEvents);
+ ););
- Info("RunSimulation", "execution time:");
- stopwatch.Print();
+ delete runLoader;
+
+ AliInfo("execution time:");
+ StdoutToAliInfo(stopwatch.Print(););
return kTRUE;
}
//_____________________________________________________________________________
-Bool_t AliSimulation::RunSDigitization(const TString& detectors)
+Bool_t AliSimulation::RunSDigitization(const char* detectors)
{
// run the digitization and produce summable digits
TStopwatch stopwatch;
stopwatch.Start();
+ AliRunLoader* runLoader = LoadRun();
+ if (!runLoader) return kFALSE;
+
TString detStr = detectors;
- TObjArray* detArray = gAlice->Detectors();
+ TObjArray* detArray = runLoader->GetAliRun()->Detectors();
for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
AliModule* det = (AliModule*) detArray->At(iDet);
if (!det || !det->IsActive()) continue;
if (IsSelected(det->GetName(), detStr)) {
- Info("RunSDigitization", "creating summable digits for %s",
- det->GetName());
+ AliInfo(Form("creating summable digits for %s", det->GetName()));
+ TStopwatch stopwatchDet;
+ stopwatchDet.Start();
det->Hits2SDigits();
+ AliInfo(Form("execution time for %s:", det->GetName()));
+ StdoutToAliInfo(stopwatchDet.Print(););
}
}
if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
- Error("RunSDigitization", "the following detectors were not found: %s",
- detStr.Data());
+ AliError(Form("the following detectors were not found: %s",
+ detStr.Data()));
if (fStopOnError) return kFALSE;
}
- Info("RunSDigitization", "execution time:");
- stopwatch.Print();
+ delete runLoader;
+
+ AliInfo("execution time:");
+ StdoutToAliInfo(stopwatch.Print(););
return kTRUE;
}
//_____________________________________________________________________________
-Bool_t AliSimulation::RunDigitization(const TString& detectors,
- const TString& excludeDetectors)
+Bool_t AliSimulation::RunDigitization(const char* detectors,
+ const char* excludeDetectors)
{
// run the digitization and produce digits from sdigits
TStopwatch stopwatch;
stopwatch.Start();
- Int_t nStreams = fBkgrdFileNames->GetEntriesFast() + 1;
- Int_t signalPerBkgrd = 1;
- if (nStreams > 1) signalPerBkgrd = fBkgrdFileNames->At(0)->GetUniqueID();
+ while (AliRunLoader::GetRunLoader()) delete AliRunLoader::GetRunLoader();
+ if (gAlice) delete gAlice;
+ gAlice = NULL;
+
+ Int_t nStreams = 1;
+ if (fBkgrdFileNames) nStreams = fBkgrdFileNames->GetEntriesFast() + 1;
+ Int_t signalPerBkgrd = GetNSignalPerBkgrd();
AliRunDigitizer* manager = new AliRunDigitizer(nStreams, signalPerBkgrd);
manager->SetInputStream(0, fGAliceFileName.Data());
for (Int_t iStream = 1; iStream < nStreams; iStream++) {
TString detStr = detectors;
TString detExcl = excludeDetectors;
- TObjArray* detArray = gAlice->Detectors();
+ manager->GetInputStream(0)->ImportgAlice();
+ AliRunLoader* runLoader =
+ AliRunLoader::GetRunLoader(manager->GetInputStream(0)->GetFolderName());
+ TObjArray* detArray = runLoader->GetAliRun()->Detectors();
for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
AliModule* det = (AliModule*) detArray->At(iDet);
if (!det || !det->IsActive()) continue;
!IsSelected(det->GetName(), detExcl)) {
AliDigitizer* digitizer = det->CreateDigitizer(manager);
if (!digitizer) {
- Error("RunDigitization", "no digitizer for %s", det->GetName());
+ AliError(Form("no digitizer for %s", det->GetName()));
if (fStopOnError) return kFALSE;
} else {
digitizer->SetRegionOfInterest(fRegionOfInterest);
}
if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
- Error("RunDigitization", "the following detectors were not found: %s",
- detStr.Data());
+ AliError(Form("the following detectors were not found: %s",
+ detStr.Data()));
if (fStopOnError) return kFALSE;
}
if (!manager->GetListOfTasks()->IsEmpty()) {
- Info("RunDigitization", "executing digitization");
+ AliInfo("executing digitization");
manager->Exec("");
}
+
delete manager;
- Info("RunDigitization", "execution time:");
- stopwatch.Print();
+ AliInfo("execution time:");
+ StdoutToAliInfo(stopwatch.Print(););
return kTRUE;
}
//_____________________________________________________________________________
-Bool_t AliSimulation::RunHitsDigitization(const TString& detectors)
+Bool_t AliSimulation::RunHitsDigitization(const char* detectors)
{
// run the digitization and produce digits from hits
TStopwatch stopwatch;
stopwatch.Start();
+ AliRunLoader* runLoader = LoadRun();
+ if (!runLoader) return kFALSE;
+
TString detStr = detectors;
- TObjArray* detArray = gAlice->Detectors();
+ TObjArray* detArray = runLoader->GetAliRun()->Detectors();
for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
AliModule* det = (AliModule*) detArray->At(iDet);
if (!det || !det->IsActive()) continue;
if (IsSelected(det->GetName(), detStr)) {
- Info("RunHitsDigitization", "creating digits from hits for %s",
- det->GetName());
+ AliInfo(Form("creating digits from hits for %s", det->GetName()));
det->Hits2Digits();
}
}
if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
- Error("RunHitsDigitization", "the following detectors were not found: %s",
- detStr.Data());
+ AliError(Form("the following detectors were not found: %s",
+ detStr.Data()));
+ if (fStopOnError) return kFALSE;
+ }
+
+ delete runLoader;
+
+ AliInfo("execution time:");
+ StdoutToAliInfo(stopwatch.Print(););
+
+ return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliSimulation::WriteRawData(const char* detectors,
+ const char* fileName,
+ Bool_t deleteIntermediateFiles)
+{
+// convert the digits to raw data
+// First DDL raw data files for the given detectors are created.
+// If a file name is given, the DDL files are then converted to a DATE file.
+// If deleteIntermediateFiles is true, the DDL raw files are deleted
+// afterwards.
+// If the file name has the extension ".root", the DATE file is converted
+// to a root file.
+// If deleteIntermediateFiles is true, the DATE file is deleted afterwards.
+
+ TStopwatch stopwatch;
+ stopwatch.Start();
+
+ if (!WriteRawFiles(detectors)) {
if (fStopOnError) return kFALSE;
}
- Info("RunHitsDigitization", "execution time:");
- stopwatch.Print();
+ TString dateFileName(fileName);
+ if (!dateFileName.IsNull()) {
+ Bool_t rootOutput = dateFileName.EndsWith(".root");
+ if (rootOutput) dateFileName += ".date";
+ if (!ConvertRawFilesToDate(dateFileName)) {
+ if (fStopOnError) return kFALSE;
+ }
+ if (deleteIntermediateFiles) {
+ AliRunLoader* runLoader = LoadRun("READ");
+ if (runLoader) for (Int_t iEvent = 0;
+ iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
+ char command[256];
+ sprintf(command, "rm -r raw%d", iEvent);
+ gSystem->Exec(command);
+ }
+ }
+
+ if (rootOutput) {
+ if (!ConvertDateToRoot(dateFileName, fileName)) {
+ if (fStopOnError) return kFALSE;
+ }
+ if (deleteIntermediateFiles) {
+ gSystem->Unlink(dateFileName);
+ }
+ }
+ }
+
+ AliInfo("execution time:");
+ StdoutToAliInfo(stopwatch.Print(););
return kTRUE;
}
+//_____________________________________________________________________________
+Bool_t AliSimulation::WriteRawFiles(const char* detectors)
+{
+// convert the digits to raw data DDL files
+
+ AliRunLoader* runLoader = LoadRun("READ");
+ if (!runLoader) return kFALSE;
+
+ // write raw data to DDL files
+ for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
+ AliInfo(Form("processing event %d", iEvent));
+ runLoader->GetEvent(iEvent);
+ TString baseDir = gSystem->WorkingDirectory();
+ char dirName[256];
+ sprintf(dirName, "raw%d", iEvent);
+ gSystem->MakeDirectory(dirName);
+ if (!gSystem->ChangeDirectory(dirName)) {
+ AliError(Form("couldn't change to directory %s", dirName));
+ if (fStopOnError) return kFALSE; else continue;
+ }
+
+ TString detStr = detectors;
+ TObjArray* detArray = runLoader->GetAliRun()->Detectors();
+ for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
+ AliModule* det = (AliModule*) detArray->At(iDet);
+ if (!det || !det->IsActive()) continue;
+ if (IsSelected(det->GetName(), detStr)) {
+ AliInfo(Form("creating raw data from digits for %s", det->GetName()));
+ det->Digits2Raw();
+ }
+ }
+
+ gSystem->ChangeDirectory(baseDir);
+ if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
+ AliError(Form("the following detectors were not found: %s",
+ detStr.Data()));
+ if (fStopOnError) return kFALSE;
+ }
+ }
+
+ delete runLoader;
+ return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliSimulation::ConvertRawFilesToDate(const char* dateFileName)
+{
+// convert raw data DDL files to a DATE file with the program "dateStream"
+
+ // DATE setup
+ const Int_t kNDetectors = 17;
+ const char* kDetectors[kNDetectors] = {"TPC", "ITSSPD", "ITSSDD", "ITSSSD",
+ "TRD", "TOF", "PHOS", "RICH",
+ "EMCAL", "MUON", "MUTR", "ZDC",
+ "PMD", "START", "VZERO", "CRT",
+ "FMD"};
+ const Int_t kDetectorDDLs[kNDetectors] = {216, 20, 12, 16,
+ 18, 72, 20, 20,
+ 22, 20, 2, 1,
+ 6, 1, 1, 1,
+ 3};
+ const Float_t kDetectorLDCs[kNDetectors] = {46, 2, 2, 1,
+ 4, 2, 1, 2,
+ 1, 2, 1, 1,
+ 1, 0.5, 0.5, 1,
+ 1};
+
+ char* path = gSystem->Which(gSystem->Getenv("PATH"), "dateStream");
+ if (!path) {
+ AliError("the program dateStream was not found");
+ if (fStopOnError) return kFALSE;
+ } else {
+ delete[] path;
+ }
+
+ AliRunLoader* runLoader = LoadRun("READ");
+ if (!runLoader) return kFALSE;
+
+ AliInfo(Form("converting raw data DDL files to DATE file %s", dateFileName));
+ char command[256];
+ sprintf(command, "dateStream -o %s -# %d -C",
+ dateFileName, runLoader->GetNumberOfEvents());
+ FILE* pipe = gSystem->OpenPipe(command, "w");
+
+ for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
+ fprintf(pipe, "GDC\n");
+ Float_t ldc = 0;
+ Int_t prevLDC = -1;
+
+ // loop over detectors and DDLs
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
+ for (Int_t iDDL = 0; iDDL < kDetectorDDLs[iDet]; iDDL++) {
+
+ Int_t ddlID = 0x100*iDet + iDDL;
+ Int_t ldcID = Int_t(ldc + 0.0001);
+ ldc += kDetectorLDCs[iDet] / kDetectorDDLs[iDet];
+
+ char rawFileName[256];
+ sprintf(rawFileName, "raw%d/%s_%d.ddl",
+ iEvent, kDetectors[iDet], ddlID);
+
+ // check existence and size of raw data file
+ FILE* file = fopen(rawFileName, "rb");
+ if (!file) continue;
+ fseek(file, 0, SEEK_END);
+ unsigned long size = ftell(file);
+ fclose(file);
+ if (!size) continue;
+
+ if (ldcID != prevLDC) {
+ fprintf(pipe, " LDC Id %d\n", ldcID);
+ prevLDC = ldcID;
+ }
+ fprintf(pipe, " Equipment Id %d Payload %s\n", ddlID, rawFileName);
+ }
+ }
+ }
+
+ Int_t result = gSystem->ClosePipe(pipe);
+
+ delete runLoader;
+ return (result == 0);
+}
+
+//_____________________________________________________________________________
+Bool_t AliSimulation::ConvertDateToRoot(const char* dateFileName,
+ const char* rootFileName)
+{
+// convert a DATE file to a root file with the program "alimdc"
+
+ // ALIMDC setup
+ const Int_t kDBSize = 1000000000;
+ const Bool_t kFilter = kFALSE;
+ const Int_t kCompression = 1;
+
+ char* path = gSystem->Which(gSystem->Getenv("PATH"), "alimdc");
+ if (!path) {
+ AliError("the program alimdc was not found");
+ if (fStopOnError) return kFALSE;
+ } else {
+ delete[] path;
+ }
+
+ AliInfo(Form("converting DATE file %s to root file %s",
+ dateFileName, rootFileName));
+
+ gSystem->Exec("rm -rf /tmp/mdc1");
+ gSystem->Exec("rm -rf /tmp/mdc2");
+ char command[256];
+ sprintf(command, "alimdc %d %d %d %s",
+ kDBSize, kFilter, kCompression, dateFileName);
+ Int_t result = gSystem->Exec(command);
+ sprintf(command, "mv /tmp/mdc1/*.root %s", rootFileName);
+ gSystem->Exec(command);
+ gSystem->Exec("rm -rf /tmp/mdc1");
+ gSystem->Exec("rm -rf /tmp/mdc2");
+
+ return (result == 0);
+}
+
+
+//_____________________________________________________________________________
+AliRunLoader* AliSimulation::LoadRun(const char* mode) const
+{
+// delete existing run loaders, open a new one and load gAlice
+
+ while (AliRunLoader::GetRunLoader()) delete AliRunLoader::GetRunLoader();
+ AliRunLoader* runLoader =
+ AliRunLoader::Open(fGAliceFileName.Data(),
+ AliConfig::GetDefaultEventFolderName(), mode);
+ if (!runLoader) {
+ AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
+ return NULL;
+ }
+ runLoader->LoadgAlice();
+ gAlice = runLoader->GetAliRun();
+ if (!gAlice) {
+ AliError(Form("no gAlice object found in file %s",
+ fGAliceFileName.Data()));
+ return NULL;
+ }
+ return runLoader;
+}
+
+//_____________________________________________________________________________
+Int_t AliSimulation::GetNSignalPerBkgrd(Int_t nEvents) const
+{
+// get or calculate the number of signal events per background event
+
+ if (!fBkgrdFileNames) return 1;
+ Int_t nBkgrdFiles = fBkgrdFileNames->GetEntriesFast();
+ if (nBkgrdFiles == 0) return 1;
+
+ // get the number of signal events
+ if (nEvents <= 0) {
+ AliRunLoader* runLoader =
+ AliRunLoader::Open(fGAliceFileName.Data(), "SIGNAL");
+ if (!runLoader) return 1;
+ nEvents = runLoader->GetNumberOfEvents();
+ delete runLoader;
+ }
+
+ Int_t result = 0;
+ for (Int_t iBkgrdFile = 0; iBkgrdFile < nBkgrdFiles; iBkgrdFile++) {
+ // get the number of background events
+ const char* fileName = ((TObjString*)
+ (fBkgrdFileNames->At(iBkgrdFile)))->GetName();
+ AliRunLoader* runLoader =
+ AliRunLoader::Open(fileName, "BKGRD");
+ if (!runLoader) continue;
+ Int_t nBkgrdEvents = runLoader->GetNumberOfEvents();
+ delete runLoader;
+
+ // get or calculate the number of signal per background events
+ Int_t nSignalPerBkgrd = fBkgrdFileNames->At(iBkgrdFile)->GetUniqueID();
+ if (nSignalPerBkgrd <= 0) {
+ nSignalPerBkgrd = (nEvents-1) / nBkgrdEvents + 1;
+ } else if (result && (result != nSignalPerBkgrd)) {
+ AliInfo(Form("the number of signal events per background event "
+ "will be changed from %d to %d for stream %d",
+ nSignalPerBkgrd, result, iBkgrdFile+1));
+ nSignalPerBkgrd = result;
+ }
+
+ if (!result) result = nSignalPerBkgrd;
+ if (nSignalPerBkgrd * nBkgrdEvents < nEvents) {
+ AliWarning(Form("not enough background events (%d) for %d signal events "
+ "using %d signal per background events for stream %d",
+ nBkgrdEvents, nEvents, nSignalPerBkgrd, iBkgrdFile+1));
+ }
+ }
+
+ return result;
+}
//_____________________________________________________________________________
Bool_t AliSimulation::IsSelected(TString detName, TString& detectors) const