"Cleaned" initialization and usage of the run number.
[u/mrichter/AliRoot.git] / STEER / AliSimulation.cxx
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 <TVirtualMCApplication.h>
109 #include <TGeoManager.h>
110 #include <TObjString.h>
111 #include <TSystem.h>
112 #include <TFile.h>
113
114 #include "AliCodeTimer.h"
115 #include "AliCDBStorage.h"
116 #include "AliCDBEntry.h"
117 #include "AliCDBManager.h"
118 #include "AliGeomManager.h"
119 #include "AliAlignObj.h"
120 #include "AliCentralTrigger.h"
121 #include "AliDAQ.h"
122 #include "AliDigitizer.h"
123 #include "AliGenerator.h"
124 #include "AliLog.h"
125 #include "AliModule.h"
126 #include "AliRun.h"
127 #include "AliRunDigitizer.h"
128 #include "AliRunLoader.h"
129 #include "AliSimulation.h"
130 #include "AliVertexGenFile.h"
131 #include "AliCentralTrigger.h"
132 #include "AliCTPRawData.h"
133 #include "AliRawReaderFile.h"
134 #include "AliRawReaderRoot.h"
135 #include "AliRawReaderDate.h"
136 #include "AliESD.h"
137 #include "AliHeader.h"
138 #include "AliGenEventHeader.h"
139 #include "AliMC.h"
140 #include "AliHLTSimulation.h"
141 #include "AliQADataMakerSteer.h"
142
143 ClassImp(AliSimulation)
144
145 AliSimulation *AliSimulation::fgInstance = 0;
146 const char* AliSimulation::fgkDetectorName[AliSimulation::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT"};
147
148 //_____________________________________________________________________________
149 AliSimulation::AliSimulation(const char* configFileName,
150                              const char* name, const char* title) :
151   TNamed(name, title),
152
153   fRunGeneration(kTRUE),
154   fRunSimulation(kTRUE),
155   fLoadAlignFromCDB(kTRUE),
156   fLoadAlObjsListOfDets("ALL"),
157   fMakeSDigits("ALL"),
158   fMakeDigits("ALL"),
159   fMakeTrigger(""),
160   fMakeDigitsFromHits(""),
161   fWriteRawData(""),
162   fRawDataFileName(""),
163   fDeleteIntermediateFiles(kFALSE),
164   fStopOnError(kFALSE),
165
166   fNEvents(1),
167   fConfigFileName(configFileName),
168   fGAliceFileName("galice.root"),
169   fEventsPerFile(),
170   fBkgrdFileNames(NULL),
171   fAlignObjArray(NULL),
172   fUseBkgrdVertex(kTRUE),
173   fRegionOfInterest(kFALSE),
174   fCDBUri(""),
175   fSpecCDBUri(),
176   fRun(-1),
177   fSeed(0),
178   fInitCDBCalled(kFALSE),
179   fInitRunNumberCalled(kFALSE),
180   fSetRunNumberFromDataCalled(kFALSE),
181   fEmbeddingFlag(kFALSE),
182   fRunQA(kTRUE), 
183   fRunHLT("default")
184 {
185 // create simulation object with default parameters
186   fgInstance = this;
187   SetGAliceFile("galice.root");
188   
189 // for QA
190    for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) 
191         fQACycles[iDet] = 999999;
192 }
193
194 //_____________________________________________________________________________
195 AliSimulation::AliSimulation(const AliSimulation& sim) :
196   TNamed(sim),
197
198   fRunGeneration(sim.fRunGeneration),
199   fRunSimulation(sim.fRunSimulation),
200   fLoadAlignFromCDB(sim.fLoadAlignFromCDB),
201   fLoadAlObjsListOfDets(sim.fLoadAlObjsListOfDets),
202   fMakeSDigits(sim.fMakeSDigits),
203   fMakeDigits(sim.fMakeDigits),
204   fMakeTrigger(sim.fMakeTrigger),
205   fMakeDigitsFromHits(sim.fMakeDigitsFromHits),
206   fWriteRawData(sim.fWriteRawData),
207   fRawDataFileName(""),
208   fDeleteIntermediateFiles(kFALSE),
209   fStopOnError(sim.fStopOnError),
210
211   fNEvents(sim.fNEvents),
212   fConfigFileName(sim.fConfigFileName),
213   fGAliceFileName(sim.fGAliceFileName),
214   fEventsPerFile(),
215   fBkgrdFileNames(NULL),
216   fAlignObjArray(NULL),
217   fUseBkgrdVertex(sim.fUseBkgrdVertex),
218   fRegionOfInterest(sim.fRegionOfInterest),
219   fCDBUri(sim.fCDBUri),
220   fSpecCDBUri(),
221   fRun(-1),
222   fSeed(0),
223   fInitCDBCalled(sim.fInitCDBCalled),
224   fInitRunNumberCalled(sim.fInitRunNumberCalled),
225   fSetRunNumberFromDataCalled(sim.fSetRunNumberFromDataCalled),
226   fEmbeddingFlag(sim.fEmbeddingFlag),
227   fRunQA(kTRUE), 
228   fRunHLT(sim.fRunHLT)
229 {
230 // copy constructor
231
232   for (Int_t i = 0; i < sim.fEventsPerFile.GetEntriesFast(); i++) {
233     if (!sim.fEventsPerFile[i]) continue;
234     fEventsPerFile.Add(sim.fEventsPerFile[i]->Clone());
235   }
236
237   fBkgrdFileNames = new TObjArray;
238   for (Int_t i = 0; i < sim.fBkgrdFileNames->GetEntriesFast(); i++) {
239     if (!sim.fBkgrdFileNames->At(i)) continue;
240     fBkgrdFileNames->Add(sim.fBkgrdFileNames->At(i)->Clone());
241   }
242
243   for (Int_t i = 0; i < sim.fSpecCDBUri.GetEntriesFast(); i++) {
244     if (sim.fSpecCDBUri[i]) fSpecCDBUri.Add(sim.fSpecCDBUri[i]->Clone());
245   }
246   fgInstance = this;
247
248 // for QA
249    for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) 
250         fQACycles[iDet] = sim.fQACycles[iDet];
251 }
252
253 //_____________________________________________________________________________
254 AliSimulation& AliSimulation::operator = (const AliSimulation& sim)
255 {
256 // assignment operator
257
258   this->~AliSimulation();
259   new(this) AliSimulation(sim);
260   return *this;
261 }
262
263 //_____________________________________________________________________________
264 AliSimulation::~AliSimulation()
265 {
266 // clean up
267
268   fEventsPerFile.Delete();
269 //  if(fAlignObjArray) fAlignObjArray->Delete(); // fAlignObjArray->RemoveAll() ???
270 //  delete fAlignObjArray; fAlignObjArray=0;
271
272   if (fBkgrdFileNames) {
273     fBkgrdFileNames->Delete();
274     delete fBkgrdFileNames;
275   }
276
277   fSpecCDBUri.Delete();
278   if (fgInstance==this) fgInstance = 0;
279
280   AliCodeTimer::Instance()->Print();
281 }
282
283
284 //_____________________________________________________________________________
285 void AliSimulation::SetNumberOfEvents(Int_t nEvents)
286 {
287 // set the number of events for one run
288
289   fNEvents = nEvents;
290 }
291
292 //_____________________________________________________________________________
293 void AliSimulation::InitCDB()
294 {
295 // activate a default CDB storage
296 // First check if we have any CDB storage set, because it is used 
297 // to retrieve the calibration and alignment constants
298
299   if (fInitCDBCalled) return;
300   fInitCDBCalled = kTRUE;
301
302   AliCDBManager* man = AliCDBManager::Instance();
303   if (man->IsDefaultStorageSet())
304   {
305     AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
306     AliWarning("Default CDB storage has been already set !");
307     AliWarning(Form("Ignoring the default storage declared in AliSimulation: %s",fCDBUri.Data()));
308     AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
309     fCDBUri = man->GetDefaultStorage()->GetURI();
310   }
311   else {
312     if (fCDBUri.Length() > 0) 
313     {
314         AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
315         AliDebug(2, Form("Default CDB storage is set to: %s", fCDBUri.Data()));
316         AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
317     } else {
318         fCDBUri="local://$ALICE_ROOT";
319         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
320         AliWarning("Default CDB storage not yet set !!!!");
321         AliWarning(Form("Setting it now to: %s", fCDBUri.Data()));
322         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
323                 
324     }
325     man->SetDefaultStorage(fCDBUri);
326   }
327
328   // Now activate the detector specific CDB storage locations
329   for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
330     TObject* obj = fSpecCDBUri[i];
331     if (!obj) continue;
332     AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
333     AliDebug(2, Form("Specific CDB storage for %s is set to: %s",obj->GetName(),obj->GetTitle()));
334     AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
335     man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
336   }
337       
338 }
339
340 //_____________________________________________________________________________
341 void AliSimulation::InitRunNumber(){
342 // check run number. If not set, set it to 0 !!!!
343   
344   if (fInitRunNumberCalled) return;
345   fInitRunNumberCalled = kTRUE;
346   
347   AliCDBManager* man = AliCDBManager::Instance();
348   if (man->GetRun() >= 0)
349   {
350     if(fRun >= 0) {
351         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
352         AliWarning(Form("Run number is already set in AliCDBManager: %d !", man->GetRun()));
353         AliWarning(Form("Ignoring the run number declared in AliSimulation: %d", fRun));
354         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
355     }
356     fRun = man->GetRun();
357   }
358   else {
359     if(fRun >= 0) {
360         AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
361         AliDebug(2, Form("Setting CDB run number to: %d",fRun));
362         AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
363     } else {
364         fRun=0;
365         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
366         AliWarning("Run number not yet set !!!!");
367         AliWarning(Form("Setting it now to: %d", fRun));
368         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
369         
370     }
371     man->SetRun(fRun);
372   }
373
374   man->Print();
375
376 }
377
378 //_____________________________________________________________________________
379 void AliSimulation::SetCDBLock() {
380   // Set CDB lock: from now on it is forbidden to reset the run number
381   // or the default storage or to activate any further storage!
382   
383   AliCDBManager::Instance()->SetLock(1);
384 }
385
386 //_____________________________________________________________________________
387 void AliSimulation::SetDefaultStorage(const char* uri) {
388 // Store the desired default CDB storage location
389 // Activate it later within the Run() method
390
391   fCDBUri = uri;
392
393 }
394
395 //_____________________________________________________________________________
396 void AliSimulation::SetSpecificStorage(const char* calibType, const char* uri) {
397 // Store a detector-specific CDB storage location
398 // Activate it later within the Run() method
399
400   AliCDBPath aPath(calibType);
401   if(!aPath.IsValid()){
402         AliError(Form("Not a valid path: %s", calibType));
403         return;
404   }
405
406   TObject* obj = fSpecCDBUri.FindObject(calibType);
407   if (obj) fSpecCDBUri.Remove(obj);
408   fSpecCDBUri.Add(new TNamed(calibType, uri));
409
410 }
411
412 //_____________________________________________________________________________
413 void AliSimulation::SetRunNumber(Int_t run)
414 {
415 // sets run number
416 // Activate it later within the Run() method
417
418         fRun = run;
419 }
420
421 //_____________________________________________________________________________
422 void AliSimulation::SetSeed(Int_t seed)
423 {
424 // sets seed number
425 // Activate it later within the Run() method
426
427         fSeed = seed;
428 }
429
430 //_____________________________________________________________________________
431 Bool_t AliSimulation::SetRunNumberFromData()
432 {
433   // Set the CDB manager run number
434   // The run number is retrieved from gAlice
435
436     if (fSetRunNumberFromDataCalled) return kTRUE;
437     fSetRunNumberFromDataCalled = kTRUE;    
438   
439     AliCDBManager* man = AliCDBManager::Instance();
440     Int_t runData = -1, runCDB = -1;
441   
442     AliRunLoader* runLoader = LoadRun("READ");
443     if (!runLoader) return kFALSE;
444     else {
445         runData = runLoader->GetAliRun()->GetHeader()->GetRun();
446         delete runLoader;
447     }
448   
449     runCDB = man->GetRun();
450     if(runCDB >= 0) {
451         if (runCDB != runData) {
452                 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
453                 AliWarning(Form("A run number was previously set in AliCDBManager: %d !", runCDB));
454                 AliWarning(Form("It will be replaced with the run number got from run header: %d !", runData));
455                 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");    
456         }
457         
458     }
459       
460     man->SetRun(runData);
461     fRun = runData;
462     
463     if(man->GetRun() < 0) {
464         AliError("Run number not properly initalized!");
465         return kFALSE;
466     }
467   
468     man->Print();
469     
470     return kTRUE;
471 }
472
473 //_____________________________________________________________________________
474 void AliSimulation::SetConfigFile(const char* fileName)
475 {
476 // set the name of the config file
477
478   fConfigFileName = fileName;
479 }
480
481 //_____________________________________________________________________________
482 void AliSimulation::SetGAliceFile(const char* fileName)
483 {
484 // set the name of the galice file
485 // the path is converted to an absolute one if it is relative
486
487   fGAliceFileName = fileName;
488   if (!gSystem->IsAbsoluteFileName(fGAliceFileName)) {
489     char* absFileName = gSystem->ConcatFileName(gSystem->WorkingDirectory(),
490                                                 fGAliceFileName);
491     fGAliceFileName = absFileName;
492     delete[] absFileName;
493   }
494
495   AliDebug(2, Form("galice file name set to %s", fileName));
496 }
497
498 //_____________________________________________________________________________
499 void AliSimulation::SetEventsPerFile(const char* detector, const char* type, 
500                                      Int_t nEvents)
501 {
502 // set the number of events per file for the given detector and data type
503 // ("Hits", "Summable Digits", "Digits", "Reconstructed Points" or "Tracks")
504
505   TNamed* obj = new TNamed(detector, type);
506   obj->SetUniqueID(nEvents);
507   fEventsPerFile.Add(obj);
508 }
509
510 //_____________________________________________________________________________
511 Bool_t AliSimulation::MisalignGeometry(AliRunLoader *runLoader)
512 {
513   // Read the alignment objects from CDB.
514   // Each detector is supposed to have the
515   // alignment objects in DET/Align/Data CDB path.
516   // All the detector objects are then collected,
517   // sorted by geometry level (starting from ALIC) and
518   // then applied to the TGeo geometry.
519   // Finally an overlaps check is performed.
520
521   if (!AliGeomManager::GetGeometry() || !AliGeomManager::GetGeometry()->IsClosed()) {
522     AliError("Can't apply the misalignment! Geometry is not loaded or it is still opened!");
523     return kFALSE;
524   }  
525   
526   // initialize CDB storage, run number, set CDB lock
527   InitCDB();
528 //  if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
529   SetCDBLock();
530     
531   Bool_t delRunLoader = kFALSE;
532   if (!runLoader) {
533     runLoader = LoadRun("READ");
534     if (!runLoader) return kFALSE;
535     delRunLoader = kTRUE;
536   }
537   
538   // Export ideal geometry 
539   if(!gAlice->IsRootGeometry()) AliGeomManager::GetGeometry()->Export("geometry.root");
540
541   // Load alignment data from CDB and apply to geometry through AliGeomManager
542   if(fLoadAlignFromCDB){
543     
544     TString detStr = fLoadAlObjsListOfDets;
545     TString loadAlObjsListOfDets = "";
546     
547     TObjArray* detArray = runLoader->GetAliRun()->Detectors();
548     for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
549       AliModule* det = (AliModule*) detArray->At(iDet);
550       if (!det || !det->IsActive()) continue;
551       if (IsSelected(det->GetName(), detStr)) {
552         //add det to list of dets to be aligned from CDB
553         loadAlObjsListOfDets += det->GetName();
554         loadAlObjsListOfDets += " ";
555       }
556     } // end loop over detectors
557     loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
558     AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
559   }else{
560     // Check if the array with alignment objects was
561     // provided by the user. If yes, apply the objects
562     // to the present TGeo geometry
563     if (fAlignObjArray) {
564       if (AliGeomManager::ApplyAlignObjsToGeom(*fAlignObjArray) == kFALSE) {
565         AliError("The misalignment of one or more volumes failed!"
566                  "Compare the list of simulated detectors and the list of detector alignment data!");
567         if (delRunLoader) delete runLoader;
568         return kFALSE;
569       }
570     }
571   }
572
573   // Update the internal geometry of modules (ITS needs it)
574   TString detStr = fLoadAlObjsListOfDets;
575   TObjArray* detArray = runLoader->GetAliRun()->Detectors();
576   for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
577
578     AliModule* det = (AliModule*) detArray->At(iDet);
579     if (!det || !det->IsActive()) continue;
580     if (IsSelected(det->GetName(), detStr)) {
581       det->UpdateInternalGeometry();
582     }
583   } // end loop over detectors
584
585
586   if (delRunLoader) delete runLoader;
587
588   return kTRUE;
589 }
590
591 //_____________________________________________________________________________
592 void AliSimulation::MergeWith(const char* fileName, Int_t nSignalPerBkgrd)
593 {
594 // add a file with background events for merging
595
596   TObjString* fileNameStr = new TObjString(fileName);
597   fileNameStr->SetUniqueID(nSignalPerBkgrd);
598   if (!fBkgrdFileNames) fBkgrdFileNames = new TObjArray;
599   fBkgrdFileNames->Add(fileNameStr);
600 }
601
602 void AliSimulation::EmbedInto(const char* fileName, Int_t nSignalPerBkgrd)
603 {
604 // add a file with background events for embeddin
605   MergeWith(fileName, nSignalPerBkgrd);
606   fEmbeddingFlag = kTRUE;
607 }
608
609 //_____________________________________________________________________________
610 Bool_t AliSimulation::Run(Int_t nEvents)
611 {
612 // run the generation, simulation and digitization
613
614  
615   AliCodeTimerAuto("")
616   
617   // Load run number and seed from environmental vars
618   ProcessEnvironmentVars();
619
620   gRandom->SetSeed(fSeed);
621    
622   if (nEvents > 0) fNEvents = nEvents;
623
624   // generation and simulation -> hits
625   if (fRunGeneration) {
626     if (!RunSimulation()) if (fStopOnError) return kFALSE;
627   }
628            
629   // initialize CDB storage from external environment
630   // (either CDB manager or AliSimulation setters),
631   // if not already done in RunSimulation()
632   InitCDB();
633   
634   // Set run number in CDBManager from data 
635   // From this point on the run number must be always loaded from data!
636   if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
637   
638   // Set CDB lock: from now on it is forbidden to reset the run number
639   // or the default storage or to activate any further storage!
640   SetCDBLock();
641
642   // If RunSimulation was not called, load the geometry and misalign it
643   if (!AliGeomManager::GetGeometry()) {
644     // Initialize the geometry manager
645     AliGeomManager::LoadGeometry("geometry.root");
646     if (!AliGeomManager::GetGeometry()) if (fStopOnError) return kFALSE;
647     // Misalign geometry
648     if(!MisalignGeometry()) if (fStopOnError) return kFALSE;
649   }
650
651   // hits -> summable digits
652   if (!fMakeSDigits.IsNull()) {
653     if (!RunSDigitization(fMakeSDigits)) if (fStopOnError) return kFALSE;
654  
655   }
656   
657
658   
659   // summable digits -> digits  
660   if (!fMakeDigits.IsNull()) {
661     if (!RunDigitization(fMakeDigits, fMakeDigitsFromHits)) {
662       if (fStopOnError) return kFALSE;
663     }
664    }
665
666   
667   
668   // hits -> digits
669   if (!fMakeDigitsFromHits.IsNull()) {
670     if (fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
671       AliWarning(Form("Merging and direct creation of digits from hits " 
672                  "was selected for some detectors. "
673                  "No merging will be done for the following detectors: %s",
674                  fMakeDigitsFromHits.Data()));
675     }
676     if (!RunHitsDigitization(fMakeDigitsFromHits)) {
677       if (fStopOnError) return kFALSE;
678     }
679   }
680
681   
682   
683   // digits -> trigger
684   if (!RunTrigger(fMakeTrigger)) {
685     if (fStopOnError) return kFALSE;
686   }
687
688   
689   
690   // digits -> raw data
691   if (!fWriteRawData.IsNull()) {
692     if (!WriteRawData(fWriteRawData, fRawDataFileName, 
693                       fDeleteIntermediateFiles)) {
694       if (fStopOnError) return kFALSE;
695     }
696   }
697
698   
699   
700   // run HLT simulation
701   if (!fRunHLT.IsNull()) {
702     if (!RunHLT()) {
703       if (fStopOnError) return kFALSE;
704     }
705   }
706   
707  // //QA
708 //      if (fRunQA) {
709 //              Bool_t rv = RunQA() ; 
710 //              if (!rv)
711 //                      if (fStopOnError) 
712 //                              return kFALSE ;         
713 //      }
714
715   // Cleanup of CDB manager: cache and active storages!
716   AliCDBManager::Instance()->ClearCache();
717
718   return kTRUE;
719 }
720
721 //_____________________________________________________________________________
722 Bool_t AliSimulation::RunTrigger(const char* descriptors)
723 {
724   // run the trigger
725
726   AliCodeTimerAuto("")
727
728   // initialize CDB storage from external environment
729   // (either CDB manager or AliSimulation setters),
730   // if not already done in RunSimulation()
731   InitCDB();
732   
733   // Set run number in CDBManager from data 
734   // From this point on the run number must be always loaded from data!
735   if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
736   
737   // Set CDB lock: from now on it is forbidden to reset the run number
738   // or the default storage or to activate any further storage!
739   SetCDBLock();
740    
741    AliRunLoader* runLoader = LoadRun("READ");
742    if (!runLoader) return kFALSE;
743    TString des = descriptors;
744
745    if (des.IsNull()) {
746      if (gAlice->GetTriggerDescriptor() != "") {
747        des = gAlice->GetTriggerDescriptor();
748      }
749      else {
750        AliWarning("No trigger descriptor is specified. Skipping the trigger simulation...");
751        return kTRUE;
752      }
753    }
754
755    runLoader->MakeTree( "GG" );
756    AliCentralTrigger* aCTP = runLoader->GetTrigger();
757   // Load Descriptors
758    aCTP->LoadDescriptor( des );
759
760   // digits -> trigger
761    if( !aCTP->RunTrigger( runLoader ) ) {
762       if (fStopOnError) {
763     //  delete aCTP;
764          return kFALSE;
765       }
766    }
767
768    delete runLoader;
769
770    return kTRUE;
771 }
772
773 //_____________________________________________________________________________
774 Bool_t AliSimulation::WriteTriggerRawData()
775 {
776   // Writes the CTP (trigger) DDL raw data
777   // Details of the format are given in the
778   // trigger TDR - pages 134 and 135.
779   AliCTPRawData writer;
780   writer.RawData();
781
782   return kTRUE;
783 }
784
785 //_____________________________________________________________________________
786 Bool_t AliSimulation::RunSimulation(Int_t nEvents)
787 {
788 // run the generation and simulation
789
790   AliCodeTimerAuto("")
791
792   // initialize CDB storage and run number from external environment
793   // (either CDB manager or AliSimulation setters)
794   InitCDB();
795   InitRunNumber();
796   SetCDBLock();
797   
798   if (!gAlice) {
799     AliError("no gAlice object. Restart aliroot and try again.");
800     return kFALSE;
801   }
802   if (gAlice->Modules()->GetEntries() > 0) {
803     AliError("gAlice was already run. Restart aliroot and try again.");
804     return kFALSE;
805   }
806
807   AliInfo(Form("initializing gAlice with config file %s",
808           fConfigFileName.Data()));
809   StdoutToAliInfo(StderrToAliError(
810     gAlice->Init(fConfigFileName.Data());
811   ););
812   
813   // Get the trigger descriptor string
814   // Either from AliSimulation or from
815   // gAlice
816   if (fMakeTrigger.IsNull()) {
817     if (gAlice->GetTriggerDescriptor() != "")
818       fMakeTrigger = gAlice->GetTriggerDescriptor();
819   }
820   else
821     gAlice->SetTriggerDescriptor(fMakeTrigger.Data());
822
823   // Set run number in CDBManager
824   AliInfo(Form("Run number: %d",AliCDBManager::Instance()->GetRun()));
825
826   AliRunLoader* runLoader = gAlice->GetRunLoader();
827   if (!runLoader) {
828              AliError(Form("gAlice has no run loader object. "
829                              "Check your config file: %s", fConfigFileName.Data()));
830              return kFALSE;
831   }
832   SetGAliceFile(runLoader->GetFileName());
833       
834   // Misalign geometry
835 #if ROOT_VERSION_CODE < 331527
836   AliGeomManager::SetGeometry(gGeoManager);
837   MisalignGeometry(runLoader);
838 #endif
839
840 //   AliRunLoader* runLoader = gAlice->GetRunLoader();
841 //   if (!runLoader) {
842 //     AliError(Form("gAlice has no run loader object. "
843 //                   "Check your config file: %s", fConfigFileName.Data()));
844 //     return kFALSE;
845 //   }
846 //   SetGAliceFile(runLoader->GetFileName());
847
848   if (!gAlice->Generator()) {
849     AliError(Form("gAlice has no generator object. "
850                   "Check your config file: %s", fConfigFileName.Data()));
851     return kFALSE;
852   }
853   if (nEvents <= 0) nEvents = fNEvents;
854
855   // get vertex from background file in case of merging
856   if (fUseBkgrdVertex &&
857       fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
858     Int_t signalPerBkgrd = GetNSignalPerBkgrd(nEvents);
859     const char* fileName = ((TObjString*)
860                             (fBkgrdFileNames->At(0)))->GetName();
861     AliInfo(Form("The vertex will be taken from the background "
862                  "file %s with nSignalPerBackground = %d", 
863                  fileName, signalPerBkgrd));
864     AliVertexGenFile* vtxGen = new AliVertexGenFile(fileName, signalPerBkgrd);
865     gAlice->Generator()->SetVertexGenerator(vtxGen);
866   }
867
868   if (!fRunSimulation) {
869     gAlice->Generator()->SetTrackingFlag(0);
870   }
871
872   // set the number of events per file for given detectors and data types
873   for (Int_t i = 0; i < fEventsPerFile.GetEntriesFast(); i++) {
874     if (!fEventsPerFile[i]) continue;
875     const char* detName = fEventsPerFile[i]->GetName();
876     const char* typeName = fEventsPerFile[i]->GetTitle();
877     TString loaderName(detName);
878     loaderName += "Loader";
879     AliLoader* loader = runLoader->GetLoader(loaderName);
880     if (!loader) {
881       AliError(Form("RunSimulation", "no loader for %s found\n"
882                     "Number of events per file not set for %s %s", 
883                     detName, typeName, detName));
884       continue;
885     }
886     AliDataLoader* dataLoader = 
887       loader->GetDataLoader(typeName);
888     if (!dataLoader) {
889       AliError(Form("no data loader for %s found\n"
890                     "Number of events per file not set for %s %s", 
891                     typeName, detName, typeName));
892       continue;
893     }
894     dataLoader->SetNumberOfEventsPerFile(fEventsPerFile[i]->GetUniqueID());
895     AliDebug(1, Form("number of events per file set to %d for %s %s",
896                      fEventsPerFile[i]->GetUniqueID(), detName, typeName));
897   }
898
899   AliInfo("running gAlice");
900   StdoutToAliInfo(StderrToAliError(
901     gAlice->Run(nEvents);
902   ););
903
904   delete runLoader;
905
906   return kTRUE;
907 }
908
909 //_____________________________________________________________________________
910 Bool_t AliSimulation::RunSDigitization(const char* detectors)
911 {
912 // run the digitization and produce summable digits
913
914   AliCodeTimerAuto("")
915
916   // initialize CDB storage, run number, set CDB lock
917   InitCDB();
918   if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
919   SetCDBLock();
920   
921   AliRunLoader* runLoader = LoadRun();
922   if (!runLoader) return kFALSE;
923
924   TString detStr = detectors;
925   TObjArray* detArray = runLoader->GetAliRun()->Detectors();
926   for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
927     AliModule* det = (AliModule*) detArray->At(iDet);
928     if (!det || !det->IsActive()) continue;
929     if (IsSelected(det->GetName(), detStr)) {
930       AliInfo(Form("creating summable digits for %s", det->GetName()));
931       AliCodeTimerAuto(Form("creating summable digits for %s", det->GetName()));
932           
933       det->Hits2SDigits();
934     }
935   }
936
937   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
938     AliError(Form("the following detectors were not found: %s",
939                   detStr.Data()));
940     if (fStopOnError) return kFALSE;
941   }
942
943   delete runLoader;
944
945   return kTRUE;
946 }
947
948
949 //_____________________________________________________________________________
950 Bool_t AliSimulation::RunDigitization(const char* detectors, 
951                                       const char* excludeDetectors)
952 {
953 // run the digitization and produce digits from sdigits
954
955   AliCodeTimerAuto("")
956
957   // initialize CDB storage, run number, set CDB lock
958   InitCDB();
959   if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
960   SetCDBLock();
961   
962   while (AliRunLoader::GetRunLoader()) delete AliRunLoader::GetRunLoader();
963   if (gAlice) delete gAlice;
964   gAlice = NULL;
965
966   Int_t nStreams = 1;
967   if (fBkgrdFileNames) nStreams = fBkgrdFileNames->GetEntriesFast() + 1;
968   Int_t signalPerBkgrd = GetNSignalPerBkgrd();
969   AliRunDigitizer* manager = new AliRunDigitizer(nStreams, signalPerBkgrd);
970   // manager->SetEmbeddingFlag(fEmbeddingFlag);
971   manager->SetInputStream(0, fGAliceFileName.Data());
972   for (Int_t iStream = 1; iStream < nStreams; iStream++) {
973     const char* fileName = ((TObjString*)
974                             (fBkgrdFileNames->At(iStream-1)))->GetName();
975     manager->SetInputStream(iStream, fileName);
976   }
977
978   TString detStr = detectors;
979   TString detExcl = excludeDetectors;
980   manager->GetInputStream(0)->ImportgAlice();
981   AliRunLoader* runLoader = 
982     AliRunLoader::GetRunLoader(manager->GetInputStream(0)->GetFolderName());
983   TObjArray* detArray = runLoader->GetAliRun()->Detectors();
984   for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
985     AliModule* det = (AliModule*) detArray->At(iDet);
986     if (!det || !det->IsActive()) continue;
987     if (IsSelected(det->GetName(), detStr) && 
988         !IsSelected(det->GetName(), detExcl)) {
989       AliDigitizer* digitizer = det->CreateDigitizer(manager);
990       
991       if (!digitizer) {
992         AliError(Form("no digitizer for %s", det->GetName()));
993         if (fStopOnError) return kFALSE;
994       } else {
995         digitizer->SetRegionOfInterest(fRegionOfInterest);
996       }
997     }
998   }
999
1000   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1001     AliError(Form("the following detectors were not found: %s", 
1002                   detStr.Data()));
1003     if (fStopOnError) return kFALSE;
1004   }
1005
1006   if (!manager->GetListOfTasks()->IsEmpty()) {
1007     AliInfo("executing digitization");
1008     manager->Exec("");
1009   }
1010
1011   delete manager;
1012
1013   return kTRUE;
1014 }
1015
1016 //_____________________________________________________________________________
1017 Bool_t AliSimulation::RunHitsDigitization(const char* detectors)
1018 {
1019 // run the digitization and produce digits from hits
1020
1021   AliCodeTimerAuto("")
1022
1023   // initialize CDB storage, run number, set CDB lock
1024   InitCDB();
1025   if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
1026   SetCDBLock();
1027   
1028   AliRunLoader* runLoader = LoadRun("READ");
1029   if (!runLoader) return kFALSE;
1030
1031   TString detStr = detectors;
1032   TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1033   for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1034     AliModule* det = (AliModule*) detArray->At(iDet);
1035     if (!det || !det->IsActive()) continue;
1036     if (IsSelected(det->GetName(), detStr)) {
1037       AliInfo(Form("creating digits from hits for %s", det->GetName()));
1038       det->Hits2Digits();
1039     }
1040   }
1041
1042   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1043     AliError(Form("the following detectors were not found: %s", 
1044                   detStr.Data()));
1045     if (fStopOnError) return kFALSE;
1046   }
1047
1048   delete runLoader;
1049   //PH Temporary fix to avoid interference with the PHOS loder/getter
1050   //PH The problem has to be solved in more general way 09/06/05
1051
1052   return kTRUE;
1053 }
1054
1055 //_____________________________________________________________________________
1056 Bool_t AliSimulation::WriteRawData(const char* detectors, 
1057                                    const char* fileName,
1058                                    Bool_t deleteIntermediateFiles)
1059 {
1060 // convert the digits to raw data
1061 // First DDL raw data files for the given detectors are created.
1062 // If a file name is given, the DDL files are then converted to a DATE file.
1063 // If deleteIntermediateFiles is true, the DDL raw files are deleted 
1064 // afterwards.
1065 // If the file name has the extension ".root", the DATE file is converted
1066 // to a root file.
1067 // If deleteIntermediateFiles is true, the DATE file is deleted afterwards.
1068
1069   AliCodeTimerAuto("")
1070
1071   if (!WriteRawFiles(detectors)) {
1072     if (fStopOnError) return kFALSE;
1073   }
1074
1075   TString dateFileName(fileName);
1076   if (!dateFileName.IsNull()) {
1077     Bool_t rootOutput = dateFileName.EndsWith(".root");
1078     if (rootOutput) dateFileName += ".date";
1079     if (!ConvertRawFilesToDate(dateFileName)) {
1080       if (fStopOnError) return kFALSE;
1081     }
1082     if (deleteIntermediateFiles) {
1083       AliRunLoader* runLoader = LoadRun("READ");
1084       if (runLoader) for (Int_t iEvent = 0; 
1085                           iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
1086         char command[256];
1087         sprintf(command, "rm -r raw%d", iEvent);
1088         gSystem->Exec(command);
1089       }
1090     }
1091
1092     if (rootOutput) {
1093       if (!ConvertDateToRoot(dateFileName, fileName)) {
1094         if (fStopOnError) return kFALSE;
1095       }
1096       if (deleteIntermediateFiles) {
1097         gSystem->Unlink(dateFileName);
1098       }
1099     }
1100   }
1101
1102   return kTRUE;
1103 }
1104
1105 //_____________________________________________________________________________
1106 Bool_t AliSimulation::WriteRawFiles(const char* detectors)
1107 {
1108 // convert the digits to raw data DDL files
1109
1110   AliCodeTimerAuto("")
1111   
1112   AliRunLoader* runLoader = LoadRun("READ");
1113   if (!runLoader) return kFALSE;
1114
1115   // write raw data to DDL files
1116   for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
1117     AliInfo(Form("processing event %d", iEvent));
1118     runLoader->GetEvent(iEvent);
1119     TString baseDir = gSystem->WorkingDirectory();
1120     char dirName[256];
1121     sprintf(dirName, "raw%d", iEvent);
1122     gSystem->MakeDirectory(dirName);
1123     if (!gSystem->ChangeDirectory(dirName)) {
1124       AliError(Form("couldn't change to directory %s", dirName));
1125       if (fStopOnError) return kFALSE; else continue;
1126     }
1127
1128     TString detStr = detectors;
1129     TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1130     for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1131       AliModule* det = (AliModule*) detArray->At(iDet);
1132       if (!det || !det->IsActive()) continue;
1133       if (IsSelected(det->GetName(), detStr)) {
1134         AliInfo(Form("creating raw data from digits for %s", det->GetName()));
1135         det->Digits2Raw();
1136       }
1137     }
1138
1139     if (!WriteTriggerRawData())
1140       if (fStopOnError) return kFALSE;
1141
1142     gSystem->ChangeDirectory(baseDir);
1143     if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1144       AliError(Form("the following detectors were not found: %s", 
1145                     detStr.Data()));
1146       if (fStopOnError) return kFALSE;
1147     }
1148   }
1149
1150   delete runLoader;
1151   
1152   return kTRUE;
1153 }
1154
1155 //_____________________________________________________________________________
1156 Bool_t AliSimulation::ConvertRawFilesToDate(const char* dateFileName)
1157 {
1158 // convert raw data DDL files to a DATE file with the program "dateStream"
1159
1160   AliCodeTimerAuto("")
1161   
1162   char* path = gSystem->Which(gSystem->Getenv("PATH"), "dateStream");
1163   if (!path) {
1164     AliError("the program dateStream was not found");
1165     if (fStopOnError) return kFALSE;
1166   } else {
1167     delete[] path;
1168   }
1169
1170   AliRunLoader* runLoader = LoadRun("READ");
1171   if (!runLoader) return kFALSE;
1172
1173   AliInfo(Form("converting raw data DDL files to DATE file %s", dateFileName));
1174   char command[256];
1175   // Note the option -s. It is used in order to avoid
1176   // the generation of SOR/EOR events.
1177   sprintf(command, "dateStream -s -D -o %s -# %d -C", 
1178           dateFileName, runLoader->GetNumberOfEvents());
1179   FILE* pipe = gSystem->OpenPipe(command, "w");
1180
1181   for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
1182     fprintf(pipe, "GDC\n");
1183     Float_t ldc = 0;
1184     Int_t prevLDC = -1;
1185
1186     // loop over detectors and DDLs
1187     for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
1188       for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls(iDet); iDDL++) {
1189
1190         Int_t ddlID = AliDAQ::DdlID(iDet,iDDL);
1191         Int_t ldcID = Int_t(ldc + 0.0001);
1192         ldc += AliDAQ::NumberOfLdcs(iDet) / AliDAQ::NumberOfDdls(iDet);
1193
1194         char rawFileName[256];
1195         sprintf(rawFileName, "raw%d/%s", 
1196                 iEvent, AliDAQ::DdlFileName(iDet,iDDL));
1197
1198         // check existence and size of raw data file
1199         FILE* file = fopen(rawFileName, "rb");
1200         if (!file) continue;
1201         fseek(file, 0, SEEK_END);
1202         unsigned long size = ftell(file);
1203         fclose(file);
1204         if (!size) continue;
1205
1206         if (ldcID != prevLDC) {
1207           fprintf(pipe, " LDC Id %d\n", ldcID);
1208           prevLDC = ldcID;
1209         }
1210         fprintf(pipe, "  Equipment Id %d Payload %s\n", ddlID, rawFileName);
1211       }
1212     }
1213   }
1214
1215   Int_t result = gSystem->ClosePipe(pipe);
1216
1217   delete runLoader;
1218   return (result == 0);
1219 }
1220
1221 //_____________________________________________________________________________
1222 Bool_t AliSimulation::ConvertDateToRoot(const char* dateFileName,
1223                                         const char* rootFileName)
1224 {
1225 // convert a DATE file to a root file with the program "alimdc"
1226
1227   // ALIMDC setup
1228   const Int_t kDBSize = 2000000000;
1229   const Int_t kTagDBSize = 1000000000;
1230   const Bool_t kFilter = kFALSE;
1231   const Int_t kCompression = 1;
1232
1233   char* path = gSystem->Which(gSystem->Getenv("PATH"), "alimdc");
1234   if (!path) {
1235     AliError("the program alimdc was not found");
1236     if (fStopOnError) return kFALSE;
1237   } else {
1238     delete[] path;
1239   }
1240
1241   AliInfo(Form("converting DATE file %s to root file %s", 
1242                dateFileName, rootFileName));
1243
1244   const char* rawDBFS[2] = { "/tmp/mdc1", "/tmp/mdc2" };
1245   const char* tagDBFS    = "/tmp/mdc1/tags";
1246
1247   // User defined file system locations
1248   if (gSystem->Getenv("ALIMDC_RAWDB1")) 
1249     rawDBFS[0] = gSystem->Getenv("ALIMDC_RAWDB1");
1250   if (gSystem->Getenv("ALIMDC_RAWDB2")) 
1251     rawDBFS[1] = gSystem->Getenv("ALIMDC_RAWDB2");
1252   if (gSystem->Getenv("ALIMDC_TAGDB")) 
1253     tagDBFS = gSystem->Getenv("ALIMDC_TAGDB");
1254
1255   gSystem->Exec(Form("rm -rf %s",rawDBFS[0]));
1256   gSystem->Exec(Form("rm -rf %s",rawDBFS[1]));
1257   gSystem->Exec(Form("rm -rf %s",tagDBFS));
1258
1259   gSystem->Exec(Form("mkdir %s",rawDBFS[0]));
1260   gSystem->Exec(Form("mkdir %s",rawDBFS[1]));
1261   gSystem->Exec(Form("mkdir %s",tagDBFS));
1262
1263   Int_t result = gSystem->Exec(Form("alimdc %d %d %d %d %s", 
1264                                     kDBSize, kTagDBSize, kFilter, kCompression, dateFileName));
1265   gSystem->Exec(Form("mv %s/*.root %s", rawDBFS[0], rootFileName));
1266
1267   gSystem->Exec(Form("rm -rf %s",rawDBFS[0]));
1268   gSystem->Exec(Form("rm -rf %s",rawDBFS[1]));
1269   gSystem->Exec(Form("rm -rf %s",tagDBFS));
1270
1271   return (result == 0);
1272 }
1273
1274
1275 //_____________________________________________________________________________
1276 AliRunLoader* AliSimulation::LoadRun(const char* mode) const
1277 {
1278 // delete existing run loaders, open a new one and load gAlice
1279
1280   while (AliRunLoader::GetRunLoader()) delete AliRunLoader::GetRunLoader();
1281   AliRunLoader* runLoader = 
1282     AliRunLoader::Open(fGAliceFileName.Data(), 
1283                        AliConfig::GetDefaultEventFolderName(), mode);
1284   if (!runLoader) {
1285     AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
1286     return NULL;
1287   }
1288   runLoader->LoadgAlice();
1289   runLoader->LoadHeader();
1290   gAlice = runLoader->GetAliRun();
1291   if (!gAlice) {
1292     AliError(Form("no gAlice object found in file %s", 
1293                   fGAliceFileName.Data()));
1294     return NULL;
1295   }
1296   return runLoader;
1297 }
1298
1299 //_____________________________________________________________________________
1300 Int_t AliSimulation::GetNSignalPerBkgrd(Int_t nEvents) const
1301 {
1302 // get or calculate the number of signal events per background event
1303
1304   if (!fBkgrdFileNames) return 1;
1305   Int_t nBkgrdFiles = fBkgrdFileNames->GetEntriesFast();
1306   if (nBkgrdFiles == 0) return 1;
1307
1308   // get the number of signal events
1309   if (nEvents <= 0) {
1310     AliRunLoader* runLoader = 
1311         AliRunLoader::Open(fGAliceFileName.Data(), "SIGNAL");
1312     if (!runLoader) return 1;
1313     
1314     nEvents = runLoader->GetNumberOfEvents();
1315     delete runLoader;
1316   }
1317
1318   Int_t result = 0;
1319   for (Int_t iBkgrdFile = 0; iBkgrdFile < nBkgrdFiles; iBkgrdFile++) {
1320     // get the number of background events
1321     const char* fileName = ((TObjString*)
1322                             (fBkgrdFileNames->At(iBkgrdFile)))->GetName();
1323     AliRunLoader* runLoader =
1324       AliRunLoader::Open(fileName, "BKGRD");
1325     if (!runLoader) continue;
1326     Int_t nBkgrdEvents = runLoader->GetNumberOfEvents();
1327     delete runLoader;
1328   
1329     // get or calculate the number of signal per background events
1330     Int_t nSignalPerBkgrd = fBkgrdFileNames->At(iBkgrdFile)->GetUniqueID();
1331     if (nSignalPerBkgrd <= 0) {
1332       nSignalPerBkgrd = (nEvents-1) / nBkgrdEvents + 1;
1333     } else if (result && (result != nSignalPerBkgrd)) {
1334       AliInfo(Form("the number of signal events per background event "
1335                    "will be changed from %d to %d for stream %d", 
1336                    nSignalPerBkgrd, result, iBkgrdFile+1));
1337       nSignalPerBkgrd = result;
1338     }
1339
1340     if (!result) result = nSignalPerBkgrd;
1341     if (nSignalPerBkgrd * nBkgrdEvents < nEvents) {
1342       AliWarning(Form("not enough background events (%d) for %d signal events "
1343                       "using %d signal per background events for stream %d",
1344                       nBkgrdEvents, nEvents, nSignalPerBkgrd, iBkgrdFile+1));
1345     }
1346   }
1347
1348   return result;
1349 }
1350
1351 //_____________________________________________________________________________
1352 Bool_t AliSimulation::IsSelected(TString detName, TString& detectors) const
1353 {
1354 // check whether detName is contained in detectors
1355 // if yes, it is removed from detectors
1356
1357   // check if all detectors are selected
1358   if ((detectors.CompareTo("ALL") == 0) ||
1359       detectors.BeginsWith("ALL ") ||
1360       detectors.EndsWith(" ALL") ||
1361       detectors.Contains(" ALL ")) {
1362     detectors = "ALL";
1363     return kTRUE;
1364   }
1365
1366   // search for the given detector
1367   Bool_t result = kFALSE;
1368   if ((detectors.CompareTo(detName) == 0) ||
1369       detectors.BeginsWith(detName+" ") ||
1370       detectors.EndsWith(" "+detName) ||
1371       detectors.Contains(" "+detName+" ")) {
1372     detectors.ReplaceAll(detName, "");
1373     result = kTRUE;
1374   }
1375
1376   // clean up the detectors string
1377   while (detectors.Contains("  ")) detectors.ReplaceAll("  ", " ");
1378   while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
1379   while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
1380
1381   return result;
1382 }
1383
1384 //_____________________________________________________________________________
1385 Bool_t AliSimulation::ConvertRaw2SDigits(const char* rawDirectory, const char* esdFileName) 
1386 {
1387 //
1388 // Steering routine  to convert raw data in directory rawDirectory/ to fake SDigits. 
1389 // These can be used for embedding of MC tracks into RAW data using the standard 
1390 // merging procedure.
1391 //
1392 // If an ESD file is given the reconstructed vertex is taken from it and stored in the event header.
1393 //
1394     if (!gAlice) {
1395         AliError("no gAlice object. Restart aliroot and try again.");
1396         return kFALSE;
1397     }
1398     if (gAlice->Modules()->GetEntries() > 0) {
1399         AliError("gAlice was already run. Restart aliroot and try again.");
1400         return kFALSE;
1401     }
1402     
1403     AliInfo(Form("initializing gAlice with config file %s",fConfigFileName.Data()));
1404     StdoutToAliInfo(StderrToAliError(gAlice->Init(fConfigFileName.Data());););
1405 //
1406 //  Initialize CDB     
1407     InitCDB();
1408     //AliCDBManager* man = AliCDBManager::Instance();
1409     //man->SetRun(0); // Should this come from rawdata header ?
1410     
1411     Int_t iDet;
1412     //
1413     // Get the runloader
1414     AliRunLoader* runLoader = gAlice->GetRunLoader();
1415     //
1416     // Open esd file if available
1417     TFile* esdFile = TFile::Open(esdFileName);
1418     Bool_t esdOK = (esdFile != 0);
1419     AliESD* esd = new AliESD;
1420     TTree* treeESD = 0;
1421     if (esdOK) {
1422         treeESD = (TTree*) esdFile->Get("esdTree");
1423         if (!treeESD) {
1424             AliWarning("No ESD tree found");
1425             esdOK = kFALSE;
1426         } else {
1427             treeESD->SetBranchAddress("ESD", &esd);
1428         }
1429     }
1430     //
1431     // Create the RawReader
1432     TString fileName(rawDirectory);
1433     AliRawReader* rawReader = 0x0;
1434     if (fileName.EndsWith("/")) {
1435       rawReader = new AliRawReaderFile(fileName);
1436     } else if (fileName.EndsWith(".root")) {
1437       rawReader = new AliRawReaderRoot(fileName);
1438     } else if (!fileName.IsNull()) {
1439       rawReader = new AliRawReaderDate(fileName);
1440       rawReader->SelectEvents(7);
1441     }
1442 //     if (!fEquipIdMap.IsNull() && fRawReader)
1443 //       fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
1444     //
1445     // Get list of detectors
1446     TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1447     //
1448     // Get Header
1449     AliHeader* header = runLoader->GetHeader();
1450     //
1451     TString detStr = fMakeSDigits;
1452     // Event loop
1453     Int_t nev = 0;
1454     while(kTRUE) {
1455         if (!(rawReader->NextEvent())) break;
1456         //
1457         // Detector loop
1458         for (iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1459             AliModule* det = (AliModule*) detArray->At(iDet);
1460             if (!det || !det->IsActive()) continue;
1461             if (IsSelected(det->GetName(), detStr)) {
1462               AliInfo(Form("Calling Raw2SDigits for %s\n", det->GetName()));
1463               det->Raw2SDigits(rawReader);
1464               rawReader->Reset();
1465             }
1466         } // detectors
1467
1468
1469         //
1470         //  If ESD information available obtain reconstructed vertex and store in header.
1471         if (esdOK) {
1472             treeESD->GetEvent(nev);
1473             const AliESDVertex* esdVertex = esd->GetPrimaryVertex();
1474             Double_t position[3];
1475             esdVertex->GetXYZ(position);
1476             AliGenEventHeader* mcHeader = new  AliGenEventHeader("ESD");
1477             TArrayF mcV;
1478             mcV.Set(3);
1479             for (Int_t i = 0; i < 3; i++) mcV[i] = position[i];
1480             mcHeader->SetPrimaryVertex(mcV);
1481             header->Reset(0,nev);
1482             header->SetGenEventHeader(mcHeader);
1483             printf("***** Saved vertex %f %f %f \n", position[0], position[1], position[2]);
1484         }
1485         nev++;
1486 //
1487 //      Finish the event
1488         runLoader->TreeE()->Fill();
1489         runLoader->SetNextEvent();
1490     } // events
1491  
1492     delete rawReader;
1493 //
1494 //  Finish the run 
1495     runLoader->CdGAFile();
1496     runLoader->WriteHeader("OVERWRITE");
1497     runLoader->WriteRunLoader();
1498
1499     return kTRUE;
1500 }
1501
1502 //_____________________________________________________________________________
1503 Int_t AliSimulation::GetDetIndex(const char* detector)
1504 {
1505   // return the detector index corresponding to detector
1506   Int_t index = -1 ; 
1507   for (index = 0; index < fgkNDetectors ; index++) {
1508     if ( strcmp(detector, fgkDetectorName[index]) == 0 )
1509           break ; 
1510   }     
1511   return index ; 
1512 }
1513
1514 //_____________________________________________________________________________
1515 Bool_t AliSimulation::RunHLT()
1516 {
1517   // Run the HLT simulation
1518   // HLT simulation is implemented in HLT/sim/AliHLTSimulation
1519   // Disabled if fRunHLT is empty, default vaule is "default".
1520   // AliSimulation::SetRunHLT can be used to set the options for HLT simulation
1521   // The default simulation depends on the HLT component libraries and their
1522   // corresponding agents which define components and chains to run. See
1523   // http://web.ift.uib.no/~kjeks/doc/alice-hlt/
1524   // http://web.ift.uib.no/~kjeks/doc/alice-hlt/classAliHLTModuleAgent.html
1525   //
1526   // The libraries to be loaded can be specified as an option.
1527   // <pre>
1528   // AliSimulation sim;
1529   // sim.SetRunHLT("libAliHLTSample.so");
1530   // </pre>
1531   // will only load <tt>libAliHLTSample.so</tt>
1532
1533   // Other available options:
1534   // \li loglevel=<i>level</i> <br>
1535   //     logging level for this processing
1536   // \li alilog=off
1537   //     disable redirection of log messages to AliLog class
1538   // \li config=<i>macro</i>
1539   //     configuration macro
1540   // \li localrec=<i>configuration</i>
1541   //     comma separated list of configurations to be run during simulation
1542
1543   int iResult=0;
1544   AliRunLoader* pRunLoader = LoadRun("READ");
1545   if (!pRunLoader) return kFALSE;
1546
1547   // initialize CDB storage, run number, set CDB lock
1548   InitCDB();
1549   if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
1550   SetCDBLock();
1551   
1552   // load the library dynamically
1553   gSystem->Load(ALIHLTSIMULATION_LIBRARY);
1554
1555   // check for the library version
1556   AliHLTSimulationGetLibraryVersion_t fctVersion=(AliHLTSimulationGetLibraryVersion_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_GET_LIBRARY_VERSION));
1557   if (!fctVersion) {
1558     AliError(Form("can not load library %s", ALIHLTSIMULATION_LIBRARY));
1559     return kFALSE;
1560   }
1561   if (fctVersion()!= ALIHLTSIMULATION_LIBRARY_VERSION) {
1562     AliError(Form("%s version does not match: compiled for version %d, loaded %d", ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_LIBRARY_VERSION, fctVersion()));
1563     return kFALSE;
1564   }
1565
1566   // print compile info
1567   typedef void (*CompileInfo)( char*& date, char*& time);
1568   CompileInfo fctInfo=(CompileInfo)gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, "CompileInfo");
1569   if (fctInfo) {
1570     char* date="";
1571     char* time="";
1572     (*fctInfo)(date, time);
1573     if (!date) date="unknown";
1574     if (!time) time="unknown";
1575     AliInfo(Form("%s build on %s (%s)", ALIHLTSIMULATION_LIBRARY, date, time));
1576   } else {
1577     AliInfo(Form("no build info available for %s", ALIHLTSIMULATION_LIBRARY));
1578   }
1579
1580   // create instance of the HLT simulation
1581   AliHLTSimulationCreateInstance_t fctCreate=(AliHLTSimulationCreateInstance_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_CREATE_INSTANCE));
1582   AliHLTSimulation* pHLT=NULL;
1583   if (fctCreate==NULL || (pHLT=(fctCreate()))==NULL) {
1584     AliError(Form("can not create instance of HLT simulation (creator %p)", fctCreate));
1585     return kFALSE;    
1586   }
1587
1588   // init the HLT simulation
1589   if (fRunHLT.CompareTo("default")==0) fRunHLT="";
1590   AliHLTSimulationInit_t fctInit=(AliHLTSimulationInit_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_INIT));
1591   if (fctInit==NULL || (iResult=(fctInit(pHLT, pRunLoader, fRunHLT.Data())))<0) {
1592     AliError(Form("can not init HLT simulation: error %d (init %p)", iResult, fctInit));
1593   } else {
1594     // run the HLT simulation
1595     AliHLTSimulationRun_t fctRun=(AliHLTSimulationRun_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_RUN));
1596     if (fctRun==NULL || (iResult=(fctRun(pHLT, pRunLoader)))<0) {
1597       AliError(Form("can not run HLT simulation: error %d (run %p)", iResult, fctRun));
1598     }
1599   }
1600
1601   // delete the instance
1602   AliHLTSimulationDeleteInstance_t fctDelete=(AliHLTSimulationDeleteInstance_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_DELETE_INSTANCE));
1603   if (fctDelete==NULL || fctDelete(pHLT)<0) {
1604     AliError(Form("can not delete instance of HLT simulation (creator %p)", fctDelete));
1605   }
1606   pHLT=NULL;
1607
1608   return iResult>=0?kTRUE:kFALSE;
1609 }
1610
1611 //_____________________________________________________________________________
1612 Bool_t AliSimulation::RunQA()
1613 {
1614         // run the QA on summable hits, digits or digits
1615
1616         AliQADataMakerSteer qas ; 
1617     qas.SetRunLoader(gAlice->GetRunLoader()) ;
1618
1619         Bool_t rv =  qas.Run("ALL", AliQA::kHITS) ; 
1620 //      qas.Reset() ; 
1621         rv *= qas.Run(fMakeSDigits.Data(), AliQA::kSDIGITS) ;   
1622 //      qas.Reset() ; 
1623         rv *= qas.Run(fMakeDigits.Data(), AliQA::kDIGITS) ;     
1624 //      qas.Reset() ; 
1625         rv *= qas.Run(fMakeDigitsFromHits.Data(), AliQA::kDIGITS) ; 
1626
1627         return rv ; 
1628 }
1629
1630 //_____________________________________________________________________________
1631 void AliSimulation::ProcessEnvironmentVars()
1632 {
1633 // Extract run number and random generator seed from env variables
1634
1635     AliInfo("Processing environment variables");
1636     
1637     // Random Number seed
1638     
1639     // first check that seed is not already set
1640     if (fSeed == 0) {
1641         if (gSystem->Getenv("CONFIG_SEED")) {
1642                 fSeed = atoi(gSystem->Getenv("CONFIG_SEED"));
1643         }
1644     } else {
1645         if (gSystem->Getenv("CONFIG_SEED")) {
1646                 AliInfo(Form("Seed for random number generation already set (%d)"
1647                              ": CONFIG_SEED variable ignored!", fSeed));
1648         }
1649     }
1650    
1651     AliInfo(Form("Seed for random number generation = %d ", fSeed)); 
1652
1653     // Run Number
1654     
1655     // first check that run number is not already set
1656     if(fRun < 0) {    
1657         if (gSystem->Getenv("DC_RUN")) {
1658                 fRun = atoi(gSystem->Getenv("DC_RUN"));
1659         }
1660     } else {
1661         if (gSystem->Getenv("DC_RUN")) {
1662                 AliInfo(Form("Run number already set (%d): DC_RUN variable ignored!", fRun));
1663         }
1664     }
1665     
1666     AliInfo(Form("Run number = %d", fRun)); 
1667 }