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