]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - STEER/AliSimulation.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
No TRD holes in front of RICH forseen
[u/mrichter/AliRoot.git] / STEER / AliSimulation.cxx
... / ...
CommitLineData
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// //
33// The name of the configuration file can be passed as argument to the //
34// AliSimulation constructor or can be specified by //
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// //
64// Background events can be merged by calling //
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. //
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. //
74// //
75// The output of raw data can be switched on by calling //
76// //
77// sim.SetWriteRawData("MUON"); // write raw data for MUON //
78// //
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// //
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. //
93// //
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// //
106///////////////////////////////////////////////////////////////////////////////
107
108#include <TObjString.h>
109#include <TStopwatch.h>
110#include <TSystem.h>
111
112#include "AliLog.h"
113#include "AliDigitizer.h"
114#include "AliGenerator.h"
115#include "AliModule.h"
116#include "AliRun.h"
117#include "AliRunDigitizer.h"
118#include "AliRunLoader.h"
119#include "AliSimulation.h"
120#include "AliVertexGenFile.h"
121
122ClassImp(AliSimulation)
123
124
125//_____________________________________________________________________________
126AliSimulation::AliSimulation(const char* configFileName,
127 const char* name, const char* title) :
128 TNamed(name, title),
129
130 fRunGeneration(kTRUE),
131 fRunSimulation(kTRUE),
132 fMakeSDigits("ALL"),
133 fMakeDigits("ALL"),
134 fMakeDigitsFromHits(""),
135 fWriteRawData(""),
136 fRawDataFileName(""),
137 fDeleteIntermediateFiles(kFALSE),
138 fStopOnError(kFALSE),
139
140 fNEvents(1),
141 fConfigFileName(configFileName),
142 fGAliceFileName("galice.root"),
143 fEventsPerFile(),
144 fBkgrdFileNames(NULL),
145 fUseBkgrdVertex(kTRUE),
146 fRegionOfInterest(kFALSE)
147{
148// create simulation object with default parameters
149
150 SetGAliceFile("galice.root");
151}
152
153//_____________________________________________________________________________
154AliSimulation::AliSimulation(const AliSimulation& sim) :
155 TNamed(sim),
156
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),
166
167 fNEvents(sim.fNEvents),
168 fConfigFileName(sim.fConfigFileName),
169 fGAliceFileName(sim.fGAliceFileName),
170 fEventsPerFile(),
171 fBkgrdFileNames(NULL),
172 fUseBkgrdVertex(sim.fUseBkgrdVertex),
173 fRegionOfInterest(sim.fRegionOfInterest)
174{
175// copy constructor
176
177 for (Int_t i = 0; i < sim.fEventsPerFile.GetEntriesFast(); i++) {
178 if (!sim.fEventsPerFile[i]) continue;
179 fEventsPerFile.Add(sim.fEventsPerFile[i]->Clone());
180 }
181
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());
186 }
187}
188
189//_____________________________________________________________________________
190AliSimulation& AliSimulation::operator = (const AliSimulation& sim)
191{
192// assignment operator
193
194 this->~AliSimulation();
195 new(this) AliSimulation(sim);
196 return *this;
197}
198
199//_____________________________________________________________________________
200AliSimulation::~AliSimulation()
201{
202// clean up
203
204 fEventsPerFile.Delete();
205
206 if (fBkgrdFileNames) {
207 fBkgrdFileNames->Delete();
208 delete fBkgrdFileNames;
209 }
210}
211
212
213//_____________________________________________________________________________
214void AliSimulation::SetNumberOfEvents(Int_t nEvents)
215{
216// set the number of events for one run
217
218 fNEvents = nEvents;
219}
220
221//_____________________________________________________________________________
222void AliSimulation::SetConfigFile(const char* fileName)
223{
224// set the name of the config file
225
226 fConfigFileName = fileName;
227}
228
229//_____________________________________________________________________________
230void AliSimulation::SetGAliceFile(const char* fileName)
231{
232// set the name of the galice file
233// the path is converted to an absolute one if it is relative
234
235 fGAliceFileName = fileName;
236 if (!gSystem->IsAbsoluteFileName(fGAliceFileName)) {
237 char* absFileName = gSystem->ConcatFileName(gSystem->WorkingDirectory(),
238 fGAliceFileName);
239 fGAliceFileName = absFileName;
240 delete[] absFileName;
241 }
242
243 AliDebug(2, Form("galice file name set to %s", fileName));
244}
245
246//_____________________________________________________________________________
247void AliSimulation::SetEventsPerFile(const char* detector, const char* type,
248 Int_t nEvents)
249{
250// set the number of events per file for the given detector and data type
251// ("Hits", "Summable Digits", "Digits", "Reconstructed Points" or "Tracks")
252
253 TNamed* obj = new TNamed(detector, type);
254 obj->SetUniqueID(nEvents);
255 fEventsPerFile.Add(obj);
256}
257
258//_____________________________________________________________________________
259void AliSimulation::MergeWith(const char* fileName, Int_t nSignalPerBkgrd)
260{
261// add a file with background events for merging
262
263 TObjString* fileNameStr = new TObjString(fileName);
264 fileNameStr->SetUniqueID(nSignalPerBkgrd);
265 if (!fBkgrdFileNames) fBkgrdFileNames = new TObjArray;
266 fBkgrdFileNames->Add(fileNameStr);
267}
268
269
270//_____________________________________________________________________________
271Bool_t AliSimulation::Run(Int_t nEvents)
272{
273// run the generation, simulation and digitization
274
275 if (nEvents > 0) fNEvents = nEvents;
276
277 // generation and simulation -> hits
278 if (fRunGeneration) {
279 if (!RunSimulation()) if (fStopOnError) return kFALSE;
280 }
281
282 // hits -> summable digits
283 if (!fMakeSDigits.IsNull()) {
284 if (!RunSDigitization(fMakeSDigits)) if (fStopOnError) return kFALSE;
285 }
286
287 // summable digits -> digits
288 if (!fMakeDigits.IsNull()) {
289 if (!RunDigitization(fMakeDigits, fMakeDigitsFromHits)) {
290 if (fStopOnError) return kFALSE;
291 }
292 }
293
294 // hits -> digits
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()));
301 }
302 if (!RunHitsDigitization(fMakeDigitsFromHits)) {
303 if (fStopOnError) return kFALSE;
304 }
305 }
306
307 // digits -> raw data
308 if (!fWriteRawData.IsNull()) {
309 if (!WriteRawData(fWriteRawData, fRawDataFileName,
310 fDeleteIntermediateFiles)) {
311 if (fStopOnError) return kFALSE;
312 }
313 }
314
315 return kTRUE;
316}
317
318//_____________________________________________________________________________
319Bool_t AliSimulation::RunSimulation(Int_t nEvents)
320{
321// run the generation and simulation
322
323 TStopwatch stopwatch;
324 stopwatch.Start();
325
326 if (!gAlice) {
327 AliError("no gAlice object. Restart aliroot and try again.");
328 return kFALSE;
329 }
330 if (gAlice->Modules()->GetEntries() > 0) {
331 AliError("gAlice was already run. Restart aliroot and try again.");
332 return kFALSE;
333 }
334
335 AliInfo(Form("initializing gAlice with config file %s",
336 fConfigFileName.Data()));
337 StdoutToAliInfo(StderrToAliError(
338 gAlice->Init(fConfigFileName.Data());
339 ););
340 AliRunLoader* runLoader = gAlice->GetRunLoader();
341 if (!runLoader) {
342 AliError(Form("gAlice has no run loader object. "
343 "Check your config file: %s", fConfigFileName.Data()));
344 return kFALSE;
345 }
346 SetGAliceFile(runLoader->GetFileName());
347
348 if (!gAlice->Generator()) {
349 AliError(Form("gAlice has no generator object. "
350 "Check your config file: %s", fConfigFileName.Data()));
351 return kFALSE;
352 }
353 if (nEvents <= 0) nEvents = fNEvents;
354
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);
366 }
367
368 if (!fRunSimulation) {
369 gAlice->Generator()->SetTrackingFlag(0);
370 }
371
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);
380 if (!loader) {
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));
384 continue;
385 }
386 AliDataLoader* dataLoader =
387 loader->GetDataLoader(typeName);
388 if (!dataLoader) {
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));
392 continue;
393 }
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));
397 }
398
399 AliInfo("running gAlice");
400 StdoutToAliInfo(StderrToAliError(
401 gAlice->Run(nEvents);
402 ););
403
404 delete runLoader;
405
406 AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
407 stopwatch.RealTime(),stopwatch.CpuTime()));
408
409 return kTRUE;
410}
411
412//_____________________________________________________________________________
413Bool_t AliSimulation::RunSDigitization(const char* detectors)
414{
415// run the digitization and produce summable digits
416
417 TStopwatch stopwatch;
418 stopwatch.Start();
419
420 AliRunLoader* runLoader = LoadRun();
421 if (!runLoader) return kFALSE;
422
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();
432 det->Hits2SDigits();
433 AliInfo(Form("Execution time for %s: R:%.2fs C:%.2fs",
434 det->GetName(),stopwatchDet.RealTime(),stopwatchDet.CpuTime()));
435 }
436 }
437
438 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
439 AliError(Form("the following detectors were not found: %s",
440 detStr.Data()));
441 if (fStopOnError) return kFALSE;
442 }
443
444 delete runLoader;
445
446 AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
447 stopwatch.RealTime(),stopwatch.CpuTime()));
448
449 return kTRUE;
450}
451
452
453//_____________________________________________________________________________
454Bool_t AliSimulation::RunDigitization(const char* detectors,
455 const char* excludeDetectors)
456{
457// run the digitization and produce digits from sdigits
458
459 TStopwatch stopwatch;
460 stopwatch.Start();
461
462 while (AliRunLoader::GetRunLoader()) delete AliRunLoader::GetRunLoader();
463 if (gAlice) delete gAlice;
464 gAlice = NULL;
465
466 Int_t nStreams = 1;
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);
475 }
476
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);
489 if (!digitizer) {
490 AliError(Form("no digitizer for %s", det->GetName()));
491 if (fStopOnError) return kFALSE;
492 } else {
493 digitizer->SetRegionOfInterest(fRegionOfInterest);
494 }
495 }
496 }
497
498 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
499 AliError(Form("the following detectors were not found: %s",
500 detStr.Data()));
501 if (fStopOnError) return kFALSE;
502 }
503
504 if (!manager->GetListOfTasks()->IsEmpty()) {
505 AliInfo("executing digitization");
506 manager->Exec("");
507 }
508
509 delete manager;
510
511 AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
512 stopwatch.RealTime(),stopwatch.CpuTime()));
513
514 return kTRUE;
515}
516
517//_____________________________________________________________________________
518Bool_t AliSimulation::RunHitsDigitization(const char* detectors)
519{
520// run the digitization and produce digits from hits
521
522 TStopwatch stopwatch;
523 stopwatch.Start();
524
525 AliRunLoader* runLoader = LoadRun("READ");
526 if (!runLoader) return kFALSE;
527
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()));
535 det->Hits2Digits();
536 }
537 }
538
539 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
540 AliError(Form("the following detectors were not found: %s",
541 detStr.Data()));
542 if (fStopOnError) return kFALSE;
543 }
544
545 //PH delete runLoader;
546 //PH Temporary fix to avoid interference with the PHOS loder/getter
547 //PH The problem has to be solved in more general way 09/06/05
548
549 AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
550 stopwatch.RealTime(),stopwatch.CpuTime()));
551
552 return kTRUE;
553}
554
555//_____________________________________________________________________________
556Bool_t AliSimulation::WriteRawData(const char* detectors,
557 const char* fileName,
558 Bool_t deleteIntermediateFiles)
559{
560// convert the digits to raw data
561// First DDL raw data files for the given detectors are created.
562// If a file name is given, the DDL files are then converted to a DATE file.
563// If deleteIntermediateFiles is true, the DDL raw files are deleted
564// afterwards.
565// If the file name has the extension ".root", the DATE file is converted
566// to a root file.
567// If deleteIntermediateFiles is true, the DATE file is deleted afterwards.
568
569 TStopwatch stopwatch;
570 stopwatch.Start();
571
572 if (!WriteRawFiles(detectors)) {
573 if (fStopOnError) return kFALSE;
574 }
575
576 TString dateFileName(fileName);
577 if (!dateFileName.IsNull()) {
578 Bool_t rootOutput = dateFileName.EndsWith(".root");
579 if (rootOutput) dateFileName += ".date";
580 if (!ConvertRawFilesToDate(dateFileName)) {
581 if (fStopOnError) return kFALSE;
582 }
583 if (deleteIntermediateFiles) {
584 AliRunLoader* runLoader = LoadRun("READ");
585 if (runLoader) for (Int_t iEvent = 0;
586 iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
587 char command[256];
588 sprintf(command, "rm -r raw%d", iEvent);
589 gSystem->Exec(command);
590 }
591 }
592
593 if (rootOutput) {
594 if (!ConvertDateToRoot(dateFileName, fileName)) {
595 if (fStopOnError) return kFALSE;
596 }
597 if (deleteIntermediateFiles) {
598 gSystem->Unlink(dateFileName);
599 }
600 }
601 }
602
603 AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
604 stopwatch.RealTime(),stopwatch.CpuTime()));
605
606 return kTRUE;
607}
608
609//_____________________________________________________________________________
610Bool_t AliSimulation::WriteRawFiles(const char* detectors)
611{
612// convert the digits to raw data DDL files
613
614 AliRunLoader* runLoader = LoadRun("READ");
615 if (!runLoader) return kFALSE;
616
617 // write raw data to DDL files
618 for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
619 AliInfo(Form("processing event %d", iEvent));
620 runLoader->GetEvent(iEvent);
621 TString baseDir = gSystem->WorkingDirectory();
622 char dirName[256];
623 sprintf(dirName, "raw%d", iEvent);
624 gSystem->MakeDirectory(dirName);
625 if (!gSystem->ChangeDirectory(dirName)) {
626 AliError(Form("couldn't change to directory %s", dirName));
627 if (fStopOnError) return kFALSE; else continue;
628 }
629
630 TString detStr = detectors;
631 TObjArray* detArray = runLoader->GetAliRun()->Detectors();
632 for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
633 AliModule* det = (AliModule*) detArray->At(iDet);
634 if (!det || !det->IsActive()) continue;
635 if (IsSelected(det->GetName(), detStr)) {
636 AliInfo(Form("creating raw data from digits for %s", det->GetName()));
637 det->Digits2Raw();
638 }
639 }
640
641 gSystem->ChangeDirectory(baseDir);
642 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
643 AliError(Form("the following detectors were not found: %s",
644 detStr.Data()));
645 if (fStopOnError) return kFALSE;
646 }
647 }
648
649 delete runLoader;
650 return kTRUE;
651}
652
653//_____________________________________________________________________________
654Bool_t AliSimulation::ConvertRawFilesToDate(const char* dateFileName)
655{
656// convert raw data DDL files to a DATE file with the program "dateStream"
657
658 // DATE setup
659 const Int_t kNDetectors = 17;
660 const char* kDetectors[kNDetectors] = {"TPC", "ITSSPD", "ITSSDD", "ITSSSD",
661 "TRD", "TOF", "PHOS", "RICH",
662 "EMCAL", "MUON", "MUTR", "ZDC",
663 "PMD", "START", "VZERO", "CRT",
664 "FMD"};
665 const Int_t kDetectorDDLs[kNDetectors] = {216, 20, 12, 16,
666 18, 72, 20, 20,
667 22, 20, 2, 1,
668 6, 1, 1, 1,
669 3};
670 const Float_t kDetectorLDCs[kNDetectors] = {46, 2, 2, 1,
671 4, 2, 1, 2,
672 1, 2, 1, 1,
673 1, 0.5, 0.5, 1,
674 1};
675
676 char* path = gSystem->Which(gSystem->Getenv("PATH"), "dateStream");
677 if (!path) {
678 AliError("the program dateStream was not found");
679 if (fStopOnError) return kFALSE;
680 } else {
681 delete[] path;
682 }
683
684 AliRunLoader* runLoader = LoadRun("READ");
685 if (!runLoader) return kFALSE;
686
687 AliInfo(Form("converting raw data DDL files to DATE file %s", dateFileName));
688 char command[256];
689 sprintf(command, "dateStream -o %s -# %d -C",
690 dateFileName, runLoader->GetNumberOfEvents());
691 FILE* pipe = gSystem->OpenPipe(command, "w");
692
693 for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
694 fprintf(pipe, "GDC\n");
695 Float_t ldc = 0;
696 Int_t prevLDC = -1;
697
698 // loop over detectors and DDLs
699 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
700 for (Int_t iDDL = 0; iDDL < kDetectorDDLs[iDet]; iDDL++) {
701
702 Int_t ddlID = 0x100*iDet + iDDL;
703 Int_t ldcID = Int_t(ldc + 0.0001);
704 ldc += kDetectorLDCs[iDet] / kDetectorDDLs[iDet];
705
706 char rawFileName[256];
707 sprintf(rawFileName, "raw%d/%s_%d.ddl",
708 iEvent, kDetectors[iDet], ddlID);
709
710 // check existence and size of raw data file
711 FILE* file = fopen(rawFileName, "rb");
712 if (!file) continue;
713 fseek(file, 0, SEEK_END);
714 unsigned long size = ftell(file);
715 fclose(file);
716 if (!size) continue;
717
718 if (ldcID != prevLDC) {
719 fprintf(pipe, " LDC Id %d\n", ldcID);
720 prevLDC = ldcID;
721 }
722 fprintf(pipe, " Equipment Id %d Payload %s\n", ddlID, rawFileName);
723 }
724 }
725 }
726
727 Int_t result = gSystem->ClosePipe(pipe);
728
729 delete runLoader;
730 return (result == 0);
731}
732
733//_____________________________________________________________________________
734Bool_t AliSimulation::ConvertDateToRoot(const char* dateFileName,
735 const char* rootFileName)
736{
737// convert a DATE file to a root file with the program "alimdc"
738
739 // ALIMDC setup
740 const Int_t kDBSize = 1000000000;
741 const Int_t kTagDBSize = 1000000000;
742 const Bool_t kFilter = kFALSE;
743 const Int_t kCompression = 1;
744
745 char* path = gSystem->Which(gSystem->Getenv("PATH"), "alimdc");
746 if (!path) {
747 AliError("the program alimdc was not found");
748 if (fStopOnError) return kFALSE;
749 } else {
750 delete[] path;
751 }
752
753 AliInfo(Form("converting DATE file %s to root file %s",
754 dateFileName, rootFileName));
755
756 gSystem->Exec("rm -rf /tmp/mdc1");
757 gSystem->Exec("rm -rf /tmp/mdc2");
758
759 gSystem->Exec("mkdir /tmp/mdc1");
760 gSystem->Exec("mkdir /tmp/mdc2");
761
762 char command[256];
763 sprintf(command, "alimdc %d %d %d %d %s",
764 kDBSize, kTagDBSize, kFilter, kCompression, dateFileName);
765 Int_t result = gSystem->Exec(command);
766 sprintf(command, "mv /tmp/mdc1/*.root %s", rootFileName);
767 gSystem->Exec(command);
768 gSystem->Exec("rm -rf /tmp/mdc1");
769 gSystem->Exec("rm -rf /tmp/mdc2");
770
771 return (result == 0);
772}
773
774
775//_____________________________________________________________________________
776AliRunLoader* AliSimulation::LoadRun(const char* mode) const
777{
778// delete existing run loaders, open a new one and load gAlice
779
780 while (AliRunLoader::GetRunLoader()) delete AliRunLoader::GetRunLoader();
781 AliRunLoader* runLoader =
782 AliRunLoader::Open(fGAliceFileName.Data(),
783 AliConfig::GetDefaultEventFolderName(), mode);
784 if (!runLoader) {
785 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
786 return NULL;
787 }
788 runLoader->LoadgAlice();
789 gAlice = runLoader->GetAliRun();
790 if (!gAlice) {
791 AliError(Form("no gAlice object found in file %s",
792 fGAliceFileName.Data()));
793 return NULL;
794 }
795 return runLoader;
796}
797
798//_____________________________________________________________________________
799Int_t AliSimulation::GetNSignalPerBkgrd(Int_t nEvents) const
800{
801// get or calculate the number of signal events per background event
802
803 if (!fBkgrdFileNames) return 1;
804 Int_t nBkgrdFiles = fBkgrdFileNames->GetEntriesFast();
805 if (nBkgrdFiles == 0) return 1;
806
807 // get the number of signal events
808 if (nEvents <= 0) {
809 AliRunLoader* runLoader =
810 AliRunLoader::Open(fGAliceFileName.Data(), "SIGNAL");
811 if (!runLoader) return 1;
812 nEvents = runLoader->GetNumberOfEvents();
813 delete runLoader;
814 }
815
816 Int_t result = 0;
817 for (Int_t iBkgrdFile = 0; iBkgrdFile < nBkgrdFiles; iBkgrdFile++) {
818 // get the number of background events
819 const char* fileName = ((TObjString*)
820 (fBkgrdFileNames->At(iBkgrdFile)))->GetName();
821 AliRunLoader* runLoader =
822 AliRunLoader::Open(fileName, "BKGRD");
823 if (!runLoader) continue;
824 Int_t nBkgrdEvents = runLoader->GetNumberOfEvents();
825 delete runLoader;
826
827 // get or calculate the number of signal per background events
828 Int_t nSignalPerBkgrd = fBkgrdFileNames->At(iBkgrdFile)->GetUniqueID();
829 if (nSignalPerBkgrd <= 0) {
830 nSignalPerBkgrd = (nEvents-1) / nBkgrdEvents + 1;
831 } else if (result && (result != nSignalPerBkgrd)) {
832 AliInfo(Form("the number of signal events per background event "
833 "will be changed from %d to %d for stream %d",
834 nSignalPerBkgrd, result, iBkgrdFile+1));
835 nSignalPerBkgrd = result;
836 }
837
838 if (!result) result = nSignalPerBkgrd;
839 if (nSignalPerBkgrd * nBkgrdEvents < nEvents) {
840 AliWarning(Form("not enough background events (%d) for %d signal events "
841 "using %d signal per background events for stream %d",
842 nBkgrdEvents, nEvents, nSignalPerBkgrd, iBkgrdFile+1));
843 }
844 }
845
846 return result;
847}
848
849//_____________________________________________________________________________
850Bool_t AliSimulation::IsSelected(TString detName, TString& detectors) const
851{
852// check whether detName is contained in detectors
853// if yes, it is removed from detectors
854
855 // check if all detectors are selected
856 if ((detectors.CompareTo("ALL") == 0) ||
857 detectors.BeginsWith("ALL ") ||
858 detectors.EndsWith(" ALL") ||
859 detectors.Contains(" ALL ")) {
860 detectors = "ALL";
861 return kTRUE;
862 }
863
864 // search for the given detector
865 Bool_t result = kFALSE;
866 if ((detectors.CompareTo(detName) == 0) ||
867 detectors.BeginsWith(detName+" ") ||
868 detectors.EndsWith(" "+detName) ||
869 detectors.Contains(" "+detName+" ")) {
870 detectors.ReplaceAll(detName, "");
871 result = kTRUE;
872 }
873
874 // clean up the detectors string
875 while (detectors.Contains(" ")) detectors.ReplaceAll(" ", " ");
876 while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
877 while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
878
879 return result;
880}