Option for kine only simulation added.
[u/mrichter/AliRoot.git] / STEER / 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 <TCint.h>
109 #include <TFile.h>
110 #include <TGeoGlobalMagField.h>
111 #include <TGeoManager.h>
112 #include <TObjString.h>
113 #include <TROOT.h>
114 #include <TSystem.h>
115 #include <TVirtualMC.h>
116 #include <TVirtualMCApplication.h>
117 #include <TDatime.h>
118 #include <TInterpreter.h>
119
120 #include "AliAlignObj.h"
121 #include "AliCDBEntry.h"
122 #include "AliCDBManager.h"
123 #include "AliGRPManager.h"
124 #include "AliCDBStorage.h"
125 #include "AliCTPRawData.h"
126 #include "AliCentralTrigger.h"
127 #include "AliCentralTrigger.h"
128 #include "AliCodeTimer.h"
129 #include "AliDAQ.h"
130 #include "AliDigitizer.h"
131 #include "AliESDEvent.h"
132 #include "AliGRPObject.h"
133 #include "AliGenEventHeader.h"
134 #include "AliGenerator.h"
135 #include "AliGeomManager.h"
136 #include "AliHLTSimulation.h"
137 #include "AliHeader.h"
138 #include "AliLego.h"
139 #include "AliLegoGenerator.h"
140 #include "AliLog.h"
141 #include "AliMC.h"
142 #include "AliMagF.h"
143 #include "AliModule.h"
144 #include "AliPDG.h"
145 #include "AliRawReaderDate.h"
146 #include "AliRawReaderFile.h"
147 #include "AliRawReaderRoot.h"
148 #include "AliRun.h"
149 #include "AliDigitizationInput.h"
150 #include "AliRunLoader.h"
151 #include "AliStack.h"
152 #include "AliSimulation.h"
153 #include "AliSysInfo.h"
154 #include "AliVertexGenFile.h"
155
156 using std::ofstream;
157 ClassImp(AliSimulation)
158
159 AliSimulation *AliSimulation::fgInstance = 0;
160 const char* AliSimulation::fgkDetectorName[AliSimulation::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE"
161 // #ifdef MFT_UPGRADE
162 //                                                                             ,"MFT"
163 // #endif 
164                                                                             ,"MFT"    // AU
165                                                                             ,"HLT"
166 };
167
168 //_____________________________________________________________________________
169 AliSimulation::AliSimulation(const char* configFileName,
170                              const char* name, const char* title) :
171   TNamed(name, title),
172
173   fRunGeneratorOnly(kFALSE),
174   fRunGeneration(kTRUE),
175   fRunSimulation(kTRUE),
176   fLoadAlignFromCDB(kTRUE),
177   fLoadAlObjsListOfDets("ALL"),
178   fMakeSDigits("ALL"),
179   fMakeDigits("ALL"),
180   fTriggerConfig(""),
181   fMakeDigitsFromHits(""),
182   fWriteRawData(""),
183   fRawDataFileName(""),
184   fDeleteIntermediateFiles(kFALSE),
185   fWriteSelRawData(kFALSE),
186   fStopOnError(kFALSE),
187   fUseMonitoring(kFALSE),
188   fNEvents(1),
189   fConfigFileName(configFileName),
190   fGAliceFileName("galice.root"),
191   fEventsPerFile(),
192   fBkgrdFileNames(NULL),
193   fAlignObjArray(NULL),
194   fUseBkgrdVertex(kTRUE),
195   fRegionOfInterest(kFALSE),
196   fCDBUri(""),
197   fQARefUri(""), 
198   fSpecCDBUri(),
199   fRun(-1),
200   fSeed(0),
201   fInitCDBCalled(kFALSE),
202   fInitRunNumberCalled(kFALSE),
203   fSetRunNumberFromDataCalled(kFALSE),
204   fEmbeddingFlag(kFALSE),
205   fLego(NULL),
206   fKey(0),
207   fUseVertexFromCDB(0),
208   fUseMagFieldFromGRP(0),
209   fGRPWriteLocation(Form("local://%s", gSystem->pwd())),
210   fUseTimeStampFromCDB(0),
211   fTimeStart(0),
212   fTimeEnd(0),
213   fQADetectors("ALL"),                  
214   fQATasks("ALL"),      
215   fRunQA(kTRUE), 
216   fEventSpecie(AliRecoParam::kDefault),
217   fWriteQAExpertData(kTRUE), 
218   fGeometryFile(),
219   fRunHLT("default"),
220   fpHLT(NULL),
221   fWriteGRPEntry(kTRUE)
222 {
223 // create simulation object with default parameters
224   fgInstance = this;
225   SetGAliceFile("galice.root");
226   
227 // for QA
228         AliQAManager * qam = AliQAManager::QAManager(AliQAv1::kSIMMODE) ; 
229         qam->SetActiveDetectors(fQADetectors) ; 
230         fQATasks = Form("%d %d %d", AliQAv1::kHITS, AliQAv1::kSDIGITS, AliQAv1::kDIGITS) ; 
231         qam->SetTasks(fQATasks) ;       
232 }
233
234 //_____________________________________________________________________________
235 AliSimulation::~AliSimulation()
236 {
237 // clean up
238
239   fEventsPerFile.Delete();
240 //  if(fAlignObjArray) fAlignObjArray->Delete(); // fAlignObjArray->RemoveAll() ???
241 //  delete fAlignObjArray; fAlignObjArray=0;
242
243   if (fBkgrdFileNames) {
244     fBkgrdFileNames->Delete();
245     delete fBkgrdFileNames;
246   }
247
248   fSpecCDBUri.Delete();
249   if (fgInstance==this) fgInstance = 0;
250
251   AliQAManager::QAManager()->ShowQA() ; 
252   AliQAManager::Destroy() ;     
253   AliCodeTimer::Instance()->Print();
254 }
255
256
257 //_____________________________________________________________________________
258 void AliSimulation::SetNumberOfEvents(Int_t nEvents)
259 {
260 // set the number of events for one run
261
262   fNEvents = nEvents;
263 }
264
265 //_____________________________________________________________________________
266 void AliSimulation::InitQA()
267 {
268   // activate a default CDB storage
269   // First check if we have any CDB storage set, because it is used 
270   // to retrieve the calibration and alignment constants
271   
272   if (fInitCDBCalled) return;
273   fInitCDBCalled = kTRUE;
274
275   AliQAManager * qam = AliQAManager::QAManager(AliQAv1::kSIMMODE) ; 
276   qam->SetActiveDetectors(fQADetectors) ; 
277   fQATasks = Form("%d %d %d", AliQAv1::kHITS, AliQAv1::kSDIGITS, AliQAv1::kDIGITS) ; 
278   qam->SetTasks(fQATasks) ;
279         if (fWriteQAExpertData)
280     qam->SetWriteExpert() ; 
281   
282   if (qam->IsDefaultStorageSet()) {
283     AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
284     AliWarning("Default QA reference storage has been already set !");
285     AliWarning(Form("Ignoring the default storage declared in AliSimulation: %s",fQARefUri.Data()));
286     AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
287     fQARefUri = qam->GetDefaultStorage()->GetURI();
288   } else {
289       if (fQARefUri.Length() > 0) {
290         AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
291         AliDebug(2, Form("Default QA reference storage is set to: %s", fQARefUri.Data()));
292         AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
293       } else {
294         fQARefUri="local://$ALICE_ROOT/QARef";
295         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
296         AliWarning("Default QA reference storage not yet set !!!!");
297         AliWarning(Form("Setting it now to: %s", fQARefUri.Data()));
298         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
299       }
300     qam->SetDefaultStorage(fQARefUri);
301   }
302 }
303
304 //_____________________________________________________________________________
305 void AliSimulation::InitCDB()
306 {
307 // activate a default CDB storage
308 // First check if we have any CDB storage set, because it is used 
309 // to retrieve the calibration and alignment constants
310
311   if (fInitCDBCalled) return;
312   fInitCDBCalled = kTRUE;
313
314   AliCDBManager* man = AliCDBManager::Instance();
315   if (man->IsDefaultStorageSet())
316   {
317     AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
318     AliWarning("Default CDB storage has been already set !");
319     AliWarning(Form("Ignoring the default storage declared in AliSimulation: %s",fCDBUri.Data()));
320     AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
321     fCDBUri = man->GetDefaultStorage()->GetURI();
322   }
323   else {
324     if (fCDBUri.Length() > 0) 
325     {
326         AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
327         AliDebug(2, Form("Default CDB storage is set to: %s", fCDBUri.Data()));
328         AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
329     } else {
330         fCDBUri="local://$ALICE_ROOT/OCDB";
331         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
332         AliWarning("Default CDB storage not yet set !!!!");
333         AliWarning(Form("Setting it now to: %s", fCDBUri.Data()));
334         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
335                 
336     }
337     man->SetDefaultStorage(fCDBUri);
338   }
339
340   // Now activate the detector specific CDB storage locations
341   for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
342     TObject* obj = fSpecCDBUri[i];
343     if (!obj) continue;
344     AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
345     AliDebug(2, Form("Specific CDB storage for %s is set to: %s",obj->GetName(),obj->GetTitle()));
346     AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
347     man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
348   }
349       
350 }
351
352 //_____________________________________________________________________________
353 void AliSimulation::InitRunNumber(){
354 // check run number. If not set, set it to 0 !!!!
355   
356   if (fInitRunNumberCalled) return;
357   fInitRunNumberCalled = kTRUE;
358   
359   AliCDBManager* man = AliCDBManager::Instance();
360   if (man->GetRun() >= 0)
361   {
362         AliFatal(Form("Run number cannot be set in AliCDBManager before start of simulation: "
363                         "Use external variable DC_RUN or AliSimulation::SetRun()!"));
364   }
365     
366   if(fRun >= 0) {
367         AliDebug(2, Form("Setting CDB run number to: %d",fRun));
368   } else {
369         fRun=0;
370         AliWarning(Form("Run number not yet set !!!! Setting it now to: %d",
371                         fRun));
372   }
373   man->SetRun(fRun);
374
375   man->Print();
376
377 }
378
379 //_____________________________________________________________________________
380 void AliSimulation::SetCDBLock() {
381   // Set CDB lock: from now on it is forbidden to reset the run number
382   // or the default storage or to activate any further storage!
383   
384   ULong64_t key = AliCDBManager::Instance()->SetLock(1);
385   if (key) fKey = key;
386 }
387
388 //_____________________________________________________________________________
389 void AliSimulation::SetDefaultStorage(const char* uri) {
390   // Store the desired default CDB storage location
391   // Activate it later within the Run() method
392   
393   fCDBUri = uri;
394   
395 }
396
397 //_____________________________________________________________________________
398 void AliSimulation::SetQARefDefaultStorage(const char* uri) {
399   // Store the desired default CDB storage location
400   // Activate it later within the Run() method
401   
402   fQARefUri = uri;
403   AliQAv1::SetQARefStorage(fQARefUri.Data()) ;
404 }
405
406 //_____________________________________________________________________________
407 void AliSimulation::SetSpecificStorage(const char* calibType, const char* uri) {
408 // Store a detector-specific CDB storage location
409 // Activate it later within the Run() method
410
411   AliCDBPath aPath(calibType);
412   if(!aPath.IsValid()){
413         AliError(Form("Not a valid path: %s", calibType));
414         return;
415   }
416
417   TObject* obj = fSpecCDBUri.FindObject(calibType);
418   if (obj) fSpecCDBUri.Remove(obj);
419   fSpecCDBUri.Add(new TNamed(calibType, uri));
420
421 }
422
423 //_____________________________________________________________________________
424 void AliSimulation::SetRunNumber(Int_t run)
425 {
426 // sets run number
427 // Activate it later within the Run() method
428
429         fRun = run;
430 }
431
432 //_____________________________________________________________________________
433 void AliSimulation::SetSeed(Int_t seed)
434 {
435 // sets seed number
436 // Activate it later within the Run() method
437
438         fSeed = seed;
439 }
440
441 //_____________________________________________________________________________
442 Bool_t AliSimulation::SetRunNumberFromData()
443 {
444   // Set the CDB manager run number
445   // The run number is retrieved from gAlice
446
447     if (fSetRunNumberFromDataCalled) return kTRUE;
448     fSetRunNumberFromDataCalled = kTRUE;    
449   
450     AliCDBManager* man = AliCDBManager::Instance();
451     Int_t runData = -1, runCDB = -1;
452   
453     AliRunLoader* runLoader = LoadRun("READ");
454     if (!runLoader) return kFALSE;
455     else {
456         runData = runLoader->GetHeader()->GetRun();
457         delete runLoader;
458     }
459   
460     runCDB = man->GetRun();
461     if(runCDB >= 0) {
462         if (runCDB != runData) {
463                 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
464                 AliWarning(Form("A run number was previously set in AliCDBManager: %d !", runCDB));
465                 AliWarning(Form("It will be replaced with the run number got from run header: %d !", runData));
466                 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");    
467         }
468         
469     }
470       
471     man->SetRun(runData);
472     fRun = runData;
473     
474     if(man->GetRun() < 0) {
475         AliError("Run number not properly initalized!");
476         return kFALSE;
477     }
478   
479     man->Print();
480     
481     return kTRUE;
482 }
483
484 //_____________________________________________________________________________
485 void AliSimulation::SetConfigFile(const char* fileName)
486 {
487 // set the name of the config file
488
489   fConfigFileName = fileName;
490 }
491
492 //_____________________________________________________________________________
493 void AliSimulation::SetGAliceFile(const char* fileName)
494 {
495 // set the name of the galice file
496 // the path is converted to an absolute one if it is relative
497
498   fGAliceFileName = fileName;
499   if (!gSystem->IsAbsoluteFileName(fGAliceFileName)) {
500     char* absFileName = gSystem->ConcatFileName(gSystem->WorkingDirectory(),
501                                                 fGAliceFileName);
502     fGAliceFileName = absFileName;
503     delete[] absFileName;
504   }
505
506   AliDebug(2, Form("galice file name set to %s", fileName));
507 }
508
509 //_____________________________________________________________________________
510 void AliSimulation::SetEventsPerFile(const char* detector, const char* type, 
511                                      Int_t nEvents)
512 {
513 // set the number of events per file for the given detector and data type
514 // ("Hits", "Summable Digits", "Digits", "Reconstructed Points" or "Tracks")
515
516   TNamed* obj = new TNamed(detector, type);
517   obj->SetUniqueID(nEvents);
518   fEventsPerFile.Add(obj);
519 }
520
521 //_____________________________________________________________________________
522 Bool_t AliSimulation::MisalignGeometry(AliRunLoader *runLoader)
523 {
524   // Read the alignment objects from CDB.
525   // Each detector is supposed to have the
526   // alignment objects in DET/Align/Data CDB path.
527   // All the detector objects are then collected,
528   // sorted by geometry level (starting from ALIC) and
529   // then applied to the TGeo geometry.
530   // Finally an overlaps check is performed.
531
532   if (!AliGeomManager::GetGeometry() || !AliGeomManager::GetGeometry()->IsClosed()) {
533     AliError("Can't apply the misalignment! Geometry is not loaded or it is still opened!");
534     return kFALSE;
535   }  
536   
537   // initialize CDB storage, run number, set CDB lock
538   InitCDB();
539 //  if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
540   SetCDBLock();
541     
542   Bool_t delRunLoader = kFALSE;
543   if (!runLoader) {
544     runLoader = LoadRun("READ");
545     if (!runLoader) return kFALSE;
546     delRunLoader = kTRUE;
547   }
548   
549   // Export ideal geometry 
550   if(!IsGeometryFromFile()) AliGeomManager::GetGeometry()->Export("geometry.root");
551
552   // Load alignment data from CDB and apply to geometry through AliGeomManager
553   if(fLoadAlignFromCDB){
554     
555     TString detStr = fLoadAlObjsListOfDets;
556     TString loadAlObjsListOfDets = "";
557     
558     TObjArray* detArray = runLoader->GetAliRun()->Detectors();
559     for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
560       AliModule* det = (AliModule*) detArray->At(iDet);
561       if (!det || !det->IsActive()) continue;
562       if (IsSelected(det->GetName(), detStr)) {
563         //add det to list of dets to be aligned from CDB
564         loadAlObjsListOfDets += det->GetName();
565         loadAlObjsListOfDets += " ";
566       }
567     } // end loop over detectors
568     loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
569     AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
570   }else{
571     // Check if the array with alignment objects was
572     // provided by the user. If yes, apply the objects
573     // to the present TGeo geometry
574     if (fAlignObjArray) {
575       if (AliGeomManager::ApplyAlignObjsToGeom(*fAlignObjArray) == kFALSE) {
576         AliError("The misalignment of one or more volumes failed!"
577                  "Compare the list of simulated detectors and the list of detector alignment data!");
578         if (delRunLoader) delete runLoader;
579         return kFALSE;
580       }
581     }
582   }
583
584   // Update the internal geometry of modules (ITS needs it)
585   TString detStr = fLoadAlObjsListOfDets;
586   TObjArray* detArray = runLoader->GetAliRun()->Detectors();
587   for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
588
589     AliModule* det = (AliModule*) detArray->At(iDet);
590     if (!det || !det->IsActive()) continue;
591     if (IsSelected(det->GetName(), detStr)) {
592       det->UpdateInternalGeometry();
593     }
594   } // end loop over detectors
595
596
597   if (delRunLoader) delete runLoader;
598
599   return kTRUE;
600 }
601
602 //_____________________________________________________________________________
603 void AliSimulation::MergeWith(const char* fileName, Int_t nSignalPerBkgrd)
604 {
605 // add a file with background events for merging
606
607   TObjString* fileNameStr = new TObjString(fileName);
608   fileNameStr->SetUniqueID(nSignalPerBkgrd);
609   if (!fBkgrdFileNames) fBkgrdFileNames = new TObjArray;
610   fBkgrdFileNames->Add(fileNameStr);
611 }
612
613 void AliSimulation::EmbedInto(const char* fileName, Int_t nSignalPerBkgrd)
614 {
615 // add a file with background events for embeddin
616   MergeWith(fileName, nSignalPerBkgrd);
617   fEmbeddingFlag = kTRUE;
618 }
619
620 //_____________________________________________________________________________
621 Bool_t AliSimulation::Run(Int_t nEvents)
622 {
623 // run the generation, simulation and digitization
624
625  
626   AliCodeTimerAuto("",0)
627   AliSysInfo::AddStamp("Start_Run");
628   
629   // Load run number and seed from environmental vars
630   ProcessEnvironmentVars();
631   AliSysInfo::AddStamp("ProcessEnvironmentVars");
632
633   gRandom->SetSeed(fSeed);
634    
635   if (nEvents > 0) fNEvents = nEvents;
636
637   // Run generator-only code on demand
638   if (fRunGeneratorOnly)
639   {
640     if(!RunGeneratorOnly())
641     {
642       if (fStopOnError) return kFALSE;
643     }
644     else
645       return kTRUE;
646   }
647
648   // create and setup the HLT instance
649   if (!fRunHLT.IsNull() && !CreateHLT()) {
650     if (fStopOnError) return kFALSE;
651     // disable HLT
652     fRunHLT="";
653   }
654   
655   // generation and simulation -> hits
656   if (fRunGeneration) {
657     if (!RunSimulation()) if (fStopOnError) return kFALSE;
658   }
659   AliSysInfo::AddStamp("RunSimulation");
660            
661   // initialize CDB storage from external environment
662   // (either CDB manager or AliSimulation setters),
663   // if not already done in RunSimulation()
664   InitCDB();
665   AliSysInfo::AddStamp("InitCDB");
666   
667   // Set run number in CDBManager from data 
668   // From this point on the run number must be always loaded from data!
669   if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
670   
671   // Set CDB lock: from now on it is forbidden to reset the run number
672   // or the default storage or to activate any further storage!
673   SetCDBLock();
674
675   // If RunSimulation was not called, load the geometry and misalign it
676   if (!AliGeomManager::GetGeometry()) {
677     // Initialize the geometry manager
678     AliGeomManager::LoadGeometry("geometry.root");
679     AliSysInfo::AddStamp("GetGeometry");
680 //    // Check that the consistency of symbolic names for the activated subdetectors
681 //    // in the geometry loaded by AliGeomManager
682 //    AliRunLoader* runLoader = LoadRun("READ");
683 //    if (!runLoader) return kFALSE;
684 //
685 //    TString detsToBeChecked = "";
686 //    TObjArray* detArray = runLoader->GetAliRun()->Detectors();
687 //    for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
688 //      AliModule* det = (AliModule*) detArray->At(iDet);
689 //      if (!det || !det->IsActive()) continue;
690 //      detsToBeChecked += det->GetName();
691 //      detsToBeChecked += " ";
692 //    } // end loop over detectors
693 //    if(!AliGeomManager::CheckSymNamesLUT(detsToBeChecked.Data()))
694     if(!AliGeomManager::CheckSymNamesLUT("ALL"))
695         AliFatalClass("Current loaded geometry differs in the definition of symbolic names!");
696         
697     if (!AliGeomManager::GetGeometry()) if (fStopOnError) return kFALSE;
698     // Misalign geometry
699     if(!MisalignGeometry()) if (fStopOnError) return kFALSE;
700   }
701   AliSysInfo::AddStamp("MissalignGeometry");
702
703
704   // hits -> summable digits
705   AliSysInfo::AddStamp("Start_sdigitization");
706   if (!fMakeSDigits.IsNull()) {
707     if (!RunSDigitization(fMakeSDigits)) if (fStopOnError) return kFALSE;
708  
709   }
710   AliSysInfo::AddStamp("Stop_sdigitization");
711   
712   AliSysInfo::AddStamp("Start_digitization");  
713   // summable digits -> digits  
714   if (!fMakeDigits.IsNull()) {
715     if (!RunDigitization(fMakeDigits, fMakeDigitsFromHits)) {
716       if (fStopOnError) return kFALSE;
717     }
718    }
719   AliSysInfo::AddStamp("Stop_digitization");
720
721   
722   
723   // hits -> digits
724   if (!fMakeDigitsFromHits.IsNull()) {
725     if (fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
726       AliWarning(Form("Merging and direct creation of digits from hits " 
727                  "was selected for some detectors. "
728                  "No merging will be done for the following detectors: %s",
729                  fMakeDigitsFromHits.Data()));
730     }
731     if (!RunHitsDigitization(fMakeDigitsFromHits)) {
732       if (fStopOnError) return kFALSE;
733     }
734   }
735
736   AliSysInfo::AddStamp("Hits2Digits");
737   
738   
739   // digits -> trigger
740   if (!fTriggerConfig.IsNull() && !RunTrigger(fTriggerConfig,fMakeDigits)) {
741     if (fStopOnError) return kFALSE;
742   }
743
744   AliSysInfo::AddStamp("RunTrigger");
745   
746   
747   // digits -> raw data
748   if (!fWriteRawData.IsNull()) {
749     if (!WriteRawData(fWriteRawData, fRawDataFileName, 
750                       fDeleteIntermediateFiles,fWriteSelRawData)) {
751       if (fStopOnError) return kFALSE;
752     }
753   }
754
755   AliSysInfo::AddStamp("WriteRaw");
756   
757   // run HLT simulation on simulated digit data if raw data is not
758   // simulated, otherwise its called as part of WriteRawData
759   if (!fRunHLT.IsNull() && fWriteRawData.IsNull()) {
760     if (!RunHLT()) {
761       if (fStopOnError) return kFALSE;
762     }
763   }
764
765   AliSysInfo::AddStamp("RunHLT");
766   
767   //QA
768   if (fRunQA) {
769       Bool_t rv = RunQA() ; 
770       if (!rv)
771           if (fStopOnError) 
772               return kFALSE ;
773   }
774
775   AliSysInfo::AddStamp("RunQA");
776
777   TString snapshotFileOut("");
778   if(TString(gSystem->Getenv("OCDB_SNAPSHOT_CREATE")) == TString("kTRUE")){ 
779       AliInfo(" ******** Creating the snapshot! *********");
780       TString snapshotFile(gSystem->Getenv("OCDB_SNAPSHOT_FILENAME")); 
781       if(!(snapshotFile.IsNull() || snapshotFile.IsWhitespace())) 
782           snapshotFileOut = snapshotFile;
783       else 
784           snapshotFileOut="OCDB.root"; 
785       AliCDBManager::Instance()->DumpToSnapshotFile(snapshotFileOut.Data(),kFALSE); 
786   }
787
788   // Cleanup of CDB manager: cache and active storages!
789   AliCDBManager::Instance()->ClearCache();
790
791   return kTRUE;
792 }
793
794 //_______________________________________________________________________
795 Bool_t AliSimulation::RunLego(const char *setup, Int_t nc1, Float_t c1min,
796                      Float_t c1max,Int_t nc2,Float_t c2min,Float_t c2max,
797                      Float_t rmin,Float_t rmax,Float_t zmax, AliLegoGenerator* gener, Int_t nev)
798 {
799   //
800   // Generates lego plots of:
801   //    - radiation length map phi vs theta
802   //    - radiation length map phi vs eta
803   //    - interaction length map
804   //    - g/cm2 length map
805   //
806   //  ntheta    bins in theta, eta
807   //  themin    minimum angle in theta (degrees)
808   //  themax    maximum angle in theta (degrees)
809   //  nphi      bins in phi
810   //  phimin    minimum angle in phi (degrees)
811   //  phimax    maximum angle in phi (degrees)
812   //  rmin      minimum radius
813   //  rmax      maximum radius
814   //  
815   //
816   //  The number of events generated = ntheta*nphi
817   //  run input parameters in macro setup (default="Config.C")
818   //
819   //  Use macro "lego.C" to visualize the 3 lego plots in spherical coordinates
820   //Begin_Html
821   /*
822     <img src="picts/AliRunLego1.gif">
823   */
824   //End_Html
825   //Begin_Html
826   /*
827     <img src="picts/AliRunLego2.gif">
828   */
829   //End_Html
830   //Begin_Html
831   /*
832     <img src="picts/AliRunLego3.gif">
833   */
834   //End_Html
835   //
836
837 // run the generation and simulation
838
839   AliCodeTimerAuto("",0)
840
841   // initialize CDB storage and run number from external environment
842   // (either CDB manager or AliSimulation setters)
843   InitCDB();
844   InitRunNumber();
845   SetCDBLock();
846   
847   if (!gAlice) {
848     AliError("no gAlice object. Restart aliroot and try again.");
849     return kFALSE;
850   }
851   if (gAlice->Modules()->GetEntries() > 0) {
852     AliError("gAlice was already run. Restart aliroot and try again.");
853     return kFALSE;
854   }
855
856   AliInfo(Form("initializing gAlice with config file %s",
857           fConfigFileName.Data()));
858
859   // Number of events 
860     if (nev == -1) nev  = nc1 * nc2;
861     
862   // check if initialisation has been done
863   // If runloader has been initialized, set the number of events per file to nc1 * nc2
864     
865   // Set new generator
866   if (!gener) gener  = new AliLegoGenerator();
867   //
868   // Configure Generator
869
870   gener->SetRadiusRange(rmin, rmax);
871   gener->SetZMax(zmax);
872   gener->SetCoor1Range(nc1, c1min, c1max);
873   gener->SetCoor2Range(nc2, c2min, c2max);
874   
875   
876   //Create Lego object  
877   fLego = new AliLego("lego",gener);
878
879   //__________________________________________________________________________
880
881   gAlice->Announce();
882
883   gROOT->LoadMacro(setup);
884   gInterpreter->ProcessLine(gAlice->GetConfigFunction());
885
886   if(AliCDBManager::Instance()->GetRun() >= 0) { 
887     SetRunNumber(AliCDBManager::Instance()->GetRun());
888   } else {
889     AliWarning("Run number not initialized!!");
890   }
891
892   AliRunLoader::Instance()->CdGAFile();
893   
894   AliPDG::AddParticlesToPdgDataBase();  
895   
896   gMC->SetMagField(TGeoGlobalMagField::Instance()->GetField());
897
898   gAlice->GetMCApp()->Init();
899   
900   
901   //Must be here because some MCs (G4) adds detectors here and not in Config.C
902   gAlice->InitLoaders();
903   AliRunLoader::Instance()->MakeTree("E");
904   
905   //
906   // Save stuff at the beginning of the file to avoid file corruption
907   AliRunLoader::Instance()->CdGAFile();
908   gAlice->Write();
909
910   //Save current generator
911   AliGenerator *gen=gAlice->GetMCApp()->Generator();
912   gAlice->GetMCApp()->ResetGenerator(gener);
913   //Prepare MC for Lego Run
914   gMC->InitLego();
915   
916   //Run Lego Object
917   
918   
919   AliRunLoader::Instance()->SetNumberOfEventsPerFile(nev);
920   gMC->ProcessRun(nev);
921   
922   // End of this run, close files
923   FinishRun();
924   // Restore current generator
925   gAlice->GetMCApp()->ResetGenerator(gen);
926   // Delete Lego Object
927   delete fLego;
928
929   return kTRUE;
930 }
931
932 //_____________________________________________________________________________
933 Bool_t AliSimulation::RunTrigger(const char* config, const char* detectors)
934 {
935   // run the trigger
936
937   AliCodeTimerAuto("",0)
938
939   // initialize CDB storage from external environment
940   // (either CDB manager or AliSimulation setters),
941   // if not already done in RunSimulation()
942   InitCDB();
943   
944   // Set run number in CDBManager from data 
945   // From this point on the run number must be always loaded from data!
946   if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
947   
948   // Set CDB lock: from now on it is forbidden to reset the run number
949   // or the default storage or to activate any further storage!
950   SetCDBLock();
951    
952    AliRunLoader* runLoader = LoadRun("READ");
953    if (!runLoader) return kFALSE;
954    TString trconfiguration = config;
955
956    if (trconfiguration.IsNull()) {
957      if(!fTriggerConfig.IsNull()) {
958        trconfiguration = fTriggerConfig;
959      }
960      else
961        AliWarning("No trigger descriptor is specified. Loading the one that is in the CDB.");
962    }
963
964    runLoader->MakeTree( "GG" );
965    AliCentralTrigger* aCTP = runLoader->GetTrigger();
966    // Load Configuration
967    if (!aCTP->LoadConfiguration( trconfiguration ))
968      return kFALSE;
969
970    // digits -> trigger
971    if( !aCTP->RunTrigger( runLoader , detectors ) ) {
972       if (fStopOnError) {
973         //  delete aCTP;
974         return kFALSE;
975       }
976    }
977
978    delete runLoader;
979
980    return kTRUE;
981 }
982
983 //_____________________________________________________________________________
984 Bool_t AliSimulation::WriteTriggerRawData()
985 {
986   // Writes the CTP (trigger) DDL raw data
987   // Details of the format are given in the
988   // trigger TDR - pages 134 and 135.
989   AliCTPRawData writer;
990   writer.RawData();
991
992   return kTRUE;
993 }
994
995 //_____________________________________________________________________________
996 Bool_t AliSimulation::RunSimulation(Int_t nEvents)
997 {
998 // run the generation and simulation
999
1000   AliCodeTimerAuto("",0)
1001
1002   // initialize CDB storage and run number from external environment
1003   // (either CDB manager or AliSimulation setters)
1004   AliSysInfo::AddStamp("RunSimulation_Begin");
1005   InitCDB();
1006   AliSysInfo::AddStamp("RunSimulation_InitCDB");
1007   InitRunNumber();
1008
1009   SetCDBLock();
1010   AliSysInfo::AddStamp("RunSimulation_SetCDBLock");
1011   
1012   if (!gAlice) {
1013     AliError("no gAlice object. Restart aliroot and try again.");
1014     return kFALSE;
1015   }
1016   if (gAlice->Modules()->GetEntries() > 0) {
1017     AliError("gAlice was already run. Restart aliroot and try again.");
1018     return kFALSE;
1019   }
1020   
1021   // Setup monitoring if requested
1022   gAlice->GetMCApp()->SetUseMonitoring(fUseMonitoring);
1023
1024   AliInfo(Form("initializing gAlice with config file %s",
1025           fConfigFileName.Data()));
1026
1027   //
1028   // Initialize ALICE Simulation run
1029   //
1030   gAlice->Announce();
1031
1032   //
1033   // If requested set the mag. field from the GRP entry.
1034   // After this the field is loccked and cannot be changed by Config.C
1035   if (fUseMagFieldFromGRP) {
1036       AliGRPManager grpM;
1037       grpM.ReadGRPEntry();
1038       grpM.SetMagField();
1039       AliInfo("Field is locked now. It cannot be changed in Config.C");
1040   }
1041 //
1042 // Execute Config.C
1043   TInterpreter::EErrorCode interpreterError=TInterpreter::kNoError;
1044   gROOT->LoadMacro(fConfigFileName.Data());
1045   Long_t interpreterResult=gInterpreter->ProcessLine(gAlice->GetConfigFunction(), &interpreterError);
1046   if (interpreterResult!=0 || interpreterError!=TInterpreter::kNoError) {
1047     AliFatal(Form("execution of config file \"%s\" failed with error %d", fConfigFileName.Data(), (int)interpreterError));
1048   }
1049   AliSysInfo::AddStamp("RunSimulation_Config");
1050
1051 //
1052 // If requested obtain the vertex position and vertex sigma_z from the CDB
1053 // This overwrites the settings from the Config.C  
1054   if (fUseVertexFromCDB) {
1055       Double_t vtxPos[3] = {0., 0., 0.}; 
1056       Double_t vtxSig[3] = {0., 0., 0.};
1057       AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
1058       if (entry) {
1059           AliESDVertex* vertex = dynamic_cast<AliESDVertex*> (entry->GetObject());
1060           if (vertex) {
1061               if(vertex->GetXRes()>2.8) { // > pipe radius --> it's a dummy object, don't use it 
1062                   entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexSPD");
1063                   if (entry) vertex = dynamic_cast<AliESDVertex*> (entry->GetObject());
1064               }
1065           }
1066           if (vertex) {
1067               vertex->GetXYZ(vtxPos);
1068               vertex->GetSigmaXYZ(vtxSig);
1069               AliInfo("Overwriting Config.C vertex settings !");
1070               AliInfo(Form("Vertex position from OCDB entry: x = %13.3f, y = %13.3f, z = %13.3f (sigma = %13.3f)\n",
1071                            vtxPos[0], vtxPos[1], vtxPos[2], vtxSig[2]));
1072               
1073               AliGenerator *gen = gAlice->GetMCApp()->Generator();
1074               gen->SetOrigin(vtxPos[0], vtxPos[1], vtxPos[2]);   // vertex position
1075               gen->SetSigmaZ(vtxSig[2]);
1076           }
1077       }
1078   }
1079
1080   // If requested we take the SOR and EOR time-stamps from the GRP and use them
1081   // in order to generate the event time-stamps
1082   if (fUseTimeStampFromCDB) {
1083     AliGRPManager grpM;
1084     grpM.ReadGRPEntry();
1085     const AliGRPObject *grpObj = grpM.GetGRPData();
1086     if (!grpObj || (grpObj->GetTimeEnd() <= grpObj->GetTimeStart())) {
1087       AliError("Missing GRP or bad SOR/EOR time-stamps! Switching off the time-stamp generation from GRP!");
1088       fTimeStart = fTimeEnd = 0;
1089       fUseTimeStampFromCDB = kFALSE;
1090     }
1091     else {
1092       fTimeStart = grpObj->GetTimeStart();
1093       fTimeEnd = grpObj->GetTimeEnd();
1094     }
1095   }
1096   
1097   if(AliCDBManager::Instance()->GetRun() >= 0) { 
1098     AliRunLoader::Instance()->SetRunNumber(AliCDBManager::Instance()->GetRun());
1099     AliRunLoader::Instance()->SetNumberOfEventsPerRun(fNEvents);
1100   } else {
1101         AliWarning("Run number not initialized!!");
1102   }
1103   
1104    AliRunLoader::Instance()->CdGAFile();
1105    
1106
1107    AliPDG::AddParticlesToPdgDataBase();  
1108
1109    gMC->SetMagField(TGeoGlobalMagField::Instance()->GetField());
1110    AliSysInfo::AddStamp("RunSimulation_GetField");
1111    gAlice->GetMCApp()->Init();
1112    AliSysInfo::AddStamp("RunSimulation_InitMCApp");
1113
1114    //Must be here because some MCs (G4) adds detectors here and not in Config.C
1115    gAlice->InitLoaders();
1116    AliRunLoader::Instance()->MakeTree("E");
1117    AliRunLoader::Instance()->LoadKinematics("RECREATE");
1118    AliRunLoader::Instance()->LoadTrackRefs("RECREATE");
1119    AliRunLoader::Instance()->LoadHits("all","RECREATE");
1120    //
1121    // Save stuff at the beginning of the file to avoid file corruption
1122    AliRunLoader::Instance()->CdGAFile();
1123    gAlice->Write();
1124    gAlice->SetEventNrInRun(-1); //important - we start Begin event from increasing current number in run
1125    AliSysInfo::AddStamp("RunSimulation_InitLoaders");
1126   //___________________________________________________________________________________________
1127   
1128   AliSysInfo::AddStamp("RunSimulation_TriggerDescriptor");
1129
1130   // Set run number in CDBManager
1131   AliInfo(Form("Run number: %d",AliCDBManager::Instance()->GetRun()));
1132
1133   AliRunLoader* runLoader = AliRunLoader::Instance();
1134   if (!runLoader) {
1135              AliError(Form("gAlice has no run loader object. "
1136                              "Check your config file: %s", fConfigFileName.Data()));
1137              return kFALSE;
1138   }
1139   SetGAliceFile(runLoader->GetFileName());
1140       
1141   // Misalign geometry
1142 #if ROOT_VERSION_CODE < 331527
1143   AliGeomManager::SetGeometry(gGeoManager);
1144   
1145   // Check that the consistency of symbolic names for the activated subdetectors
1146   // in the geometry loaded by AliGeomManager
1147   TString detsToBeChecked = "";
1148   TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1149   for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1150     AliModule* det = (AliModule*) detArray->At(iDet);
1151     if (!det || !det->IsActive()) continue;
1152     detsToBeChecked += det->GetName();
1153     detsToBeChecked += " ";
1154   } // end loop over detectors
1155   if(!AliGeomManager::CheckSymNamesLUT(detsToBeChecked.Data()))
1156     AliFatalClass("Current loaded geometry differs in the definition of symbolic names!");
1157   MisalignGeometry(runLoader);
1158   AliSysInfo::AddStamp("RunSimulation_MisalignGeometry");
1159 #endif
1160
1161 //   AliRunLoader* runLoader = AliRunLoader::Instance();
1162 //   if (!runLoader) {
1163 //     AliError(Form("gAlice has no run loader object. "
1164 //                   "Check your config file: %s", fConfigFileName.Data()));
1165 //     return kFALSE;
1166 //   }
1167 //   SetGAliceFile(runLoader->GetFileName());
1168
1169   if (!gAlice->GetMCApp()->Generator()) {
1170     AliError(Form("gAlice has no generator object. "
1171                   "Check your config file: %s", fConfigFileName.Data()));
1172     return kFALSE;
1173   }
1174
1175   // Write GRP entry corresponding to the setting found in Cofig.C
1176   if (fWriteGRPEntry)
1177     WriteGRPEntry();
1178   AliSysInfo::AddStamp("RunSimulation_WriteGRP");
1179
1180   if (nEvents <= 0) nEvents = fNEvents;
1181
1182   // get vertex from background file in case of merging
1183   if (fUseBkgrdVertex &&
1184       fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
1185     Int_t signalPerBkgrd = GetNSignalPerBkgrd(nEvents);
1186     const char* fileName = ((TObjString*)
1187                             (fBkgrdFileNames->At(0)))->GetName();
1188     AliInfo(Form("The vertex will be taken from the background "
1189                  "file %s with nSignalPerBackground = %d", 
1190                  fileName, signalPerBkgrd));
1191     AliVertexGenFile* vtxGen = new AliVertexGenFile(fileName, signalPerBkgrd);
1192     gAlice->GetMCApp()->Generator()->SetVertexGenerator(vtxGen);
1193   }
1194
1195   if (!fRunSimulation) {
1196     gAlice->GetMCApp()->Generator()->SetTrackingFlag(0);
1197   }
1198
1199   // set the number of events per file for given detectors and data types
1200   for (Int_t i = 0; i < fEventsPerFile.GetEntriesFast(); i++) {
1201     if (!fEventsPerFile[i]) continue;
1202     const char* detName = fEventsPerFile[i]->GetName();
1203     const char* typeName = fEventsPerFile[i]->GetTitle();
1204     TString loaderName(detName);
1205     loaderName += "Loader";
1206     AliLoader* loader = runLoader->GetLoader(loaderName);
1207     if (!loader) {
1208       AliError(Form("RunSimulation no loader for %s found\n Number of events per file not set for %s %s", 
1209                     detName, typeName, detName));
1210       continue;
1211     }
1212     AliDataLoader* dataLoader = 
1213       loader->GetDataLoader(typeName);
1214     if (!dataLoader) {
1215       AliError(Form("no data loader for %s found\n"
1216                     "Number of events per file not set for %s %s", 
1217                     typeName, detName, typeName));
1218       continue;
1219     }
1220     dataLoader->SetNumberOfEventsPerFile(fEventsPerFile[i]->GetUniqueID());
1221     AliDebug(1, Form("number of events per file set to %d for %s %s",
1222                      fEventsPerFile[i]->GetUniqueID(), detName, typeName));
1223   }
1224
1225   AliInfo("running gAlice");
1226   AliSysInfo::AddStamp("Start_ProcessRun");
1227
1228   // Create the Root Tree with one branch per detector
1229   //Hits moved to begin event -> now we are crating separate tree for each event
1230   gMC->ProcessRun(nEvents);
1231
1232   // End of this run, close files
1233   if(nEvents>0) FinishRun();
1234
1235   AliSysInfo::AddStamp("Stop_ProcessRun");
1236   delete runLoader;
1237
1238   return kTRUE;
1239 }
1240
1241 //_____________________________________________________________________________
1242 Bool_t AliSimulation::RunGeneratorOnly()
1243 {
1244   // Execute Config.C
1245   TInterpreter::EErrorCode interpreterError=TInterpreter::kNoError;
1246   gROOT->LoadMacro(fConfigFileName.Data());
1247   Long_t interpreterResult=gInterpreter->ProcessLine(gAlice->GetConfigFunction(), &interpreterError);
1248   if (interpreterResult!=0 || interpreterError!=TInterpreter::kNoError) {
1249     AliFatal(Form("execution of config file \"%s\" failed with error %d", fConfigFileName.Data(), (int)interpreterError));
1250   }
1251
1252   // Setup the runloader and generator, check if everything is OK
1253   AliRunLoader* runLoader = AliRunLoader::Instance();
1254   AliGenerator* generator = gAlice->GetMCApp()->Generator();
1255   if (!runLoader) {
1256     AliError(Form("gAlice has no run loader object. "
1257                   "Check your config file: %s", fConfigFileName.Data()));
1258     return kFALSE;
1259   }
1260   if (!generator) {
1261     AliError(Form("gAlice has no generator object. "
1262                   "Check your config file: %s", fConfigFileName.Data()));
1263     return kFALSE;
1264   }
1265
1266   runLoader->LoadKinematics("RECREATE");
1267   runLoader->MakeTree("E");
1268
1269   // Create stack and header
1270   runLoader->MakeStack();
1271   AliStack*  stack      = runLoader->Stack();
1272   AliHeader* header     = runLoader->GetHeader();
1273
1274   // Intialize generator
1275   generator->Init();
1276   generator->SetStack(stack);
1277
1278   // Run main generator loop
1279
1280   for (Int_t iev=0; iev<fNEvents; iev++)
1281   {
1282     // Initialize event
1283     header->Reset(0,iev);
1284     runLoader->SetEventNumber(iev);
1285     stack->Reset();
1286     runLoader->MakeTree("K");
1287
1288     // Generate event
1289     generator->Generate();
1290
1291     // Finish event
1292     header->SetNprimary(stack->GetNprimary());
1293     header->SetNtrack(stack->GetNtrack());
1294     stack->FinishEvent();
1295     header->SetStack(stack);
1296     runLoader->TreeE()->Fill();
1297     runLoader->WriteKinematics("OVERWRITE");
1298   }
1299
1300   // Finalize
1301   generator->FinishRun();
1302   // Write file
1303   runLoader->WriteHeader("OVERWRITE");
1304   generator->Write();
1305   runLoader->Write();
1306 }
1307
1308 //_____________________________________________________________________________
1309 Bool_t AliSimulation::RunSDigitization(const char* detectors)
1310 {
1311 // run the digitization and produce summable digits
1312   static Int_t eventNr=0;
1313   AliCodeTimerAuto("",0) ;
1314
1315   // initialize CDB storage, run number, set CDB lock
1316   InitCDB();
1317   if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
1318   SetCDBLock();
1319   
1320   AliRunLoader* runLoader = LoadRun();
1321   if (!runLoader) return kFALSE;
1322
1323   TString detStr = detectors;
1324   TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1325   for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1326     AliModule* det = (AliModule*) detArray->At(iDet);
1327     if (!det || !det->IsActive()) continue;
1328     if (IsSelected(det->GetName(), detStr)) {
1329       AliInfo(Form("creating summable digits for %s", det->GetName()));
1330       AliCodeTimerStart(Form("creating summable digits for %s", det->GetName()));
1331       det->Hits2SDigits();
1332       AliCodeTimerStop(Form("creating summable digits for %s", det->GetName()));
1333       AliSysInfo::AddStamp(Form("Digit_%s_%d",det->GetName(),eventNr), 0,1, eventNr);
1334     }
1335   }
1336
1337   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1338     AliError(Form("the following detectors were not found: %s",
1339                   detStr.Data()));
1340     if (fStopOnError) return kFALSE;
1341   }
1342   eventNr++;
1343   delete runLoader;
1344
1345   return kTRUE;
1346 }
1347
1348
1349 //_____________________________________________________________________________
1350 Bool_t AliSimulation::RunDigitization(const char* detectors, 
1351                                       const char* excludeDetectors)
1352 {
1353 // run the digitization and produce digits from sdigits
1354
1355   AliCodeTimerAuto("",0)
1356
1357   // initialize CDB storage, run number, set CDB lock
1358   InitCDB();
1359   if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
1360   SetCDBLock();
1361   
1362   delete AliRunLoader::Instance();
1363   delete gAlice;
1364   gAlice = NULL;
1365
1366   Int_t nStreams = 1;
1367   if (fBkgrdFileNames) nStreams = fBkgrdFileNames->GetEntriesFast() + 1;
1368   Int_t signalPerBkgrd = GetNSignalPerBkgrd();
1369   AliDigitizationInput digInp(nStreams, signalPerBkgrd);
1370   // digInp.SetEmbeddingFlag(fEmbeddingFlag);
1371   digInp.SetRegionOfInterest(fRegionOfInterest);
1372   digInp.SetInputStream(0, fGAliceFileName.Data());
1373   for (Int_t iStream = 1; iStream < nStreams; iStream++) {
1374     const char* fileName = ((TObjString*)(fBkgrdFileNames->At(iStream-1)))->GetName();
1375     digInp.SetInputStream(iStream, fileName);
1376   }
1377   TObjArray detArr;
1378   detArr.SetOwner(kTRUE);
1379   TString detStr = detectors;
1380   TString detExcl = excludeDetectors;
1381   if (!static_cast<AliStream*>(digInp.GetInputStream(0))->ImportgAlice()) {
1382     AliError("Error occured while getting gAlice from Input 0");
1383     return kFALSE;
1384   }
1385   AliRunLoader* runLoader = AliRunLoader::GetRunLoader(digInp.GetInputStream(0)->GetFolderName());
1386   TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1387   for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1388     AliModule* det = (AliModule*) detArray->At(iDet);
1389     if (!det || !det->IsActive()) continue;
1390     if (!IsSelected(det->GetName(), detStr) || IsSelected(det->GetName(), detExcl)) continue;
1391     AliDigitizer* digitizer = det->CreateDigitizer(&digInp);
1392     if (!digitizer || !digitizer->Init()) {
1393       AliError(Form("no digitizer for %s", det->GetName()));
1394       if (fStopOnError) return kFALSE;
1395       else continue;
1396     }
1397     detArr.AddLast(digitizer);    
1398     AliInfo(Form("Created digitizer from SDigits -> Digits for %s", det->GetName()));    
1399   }
1400   //
1401   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1402     AliError(Form("the following detectors were not found: %s", detStr.Data()));
1403     if (fStopOnError) return kFALSE;
1404   }
1405   //
1406   Int_t ndigs = detArr.GetEntriesFast();
1407   Int_t eventsCreated = 0;
1408   AliRunLoader* outRl =  digInp.GetOutRunLoader();
1409   while ((eventsCreated++ < fNEvents) || (fNEvents < 0)) {
1410     if (!digInp.ConnectInputTrees()) break;
1411     digInp.InitEvent(); //this must be after call of Connect Input tress.
1412     if (outRl) outRl->SetEventNumber(eventsCreated-1);
1413     static_cast<AliStream*>(digInp.GetInputStream(0))->ImportgAlice(); // use gAlice of the first input stream
1414     for (int id=0;id<ndigs;id++) ((AliDigitizer*)detArr[id])->Digitize("");
1415     digInp.FinishEvent();
1416   };
1417   digInp.FinishGlobal();
1418   //
1419   return kTRUE;
1420 }
1421
1422 //_____________________________________________________________________________
1423 Bool_t AliSimulation::RunHitsDigitization(const char* detectors)
1424 {
1425 // run the digitization and produce digits from hits
1426
1427   AliCodeTimerAuto("",0)
1428
1429   // initialize CDB storage, run number, set CDB lock
1430   InitCDB();
1431   if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
1432   SetCDBLock();
1433   
1434   AliRunLoader* runLoader = LoadRun("READ");
1435   if (!runLoader) return kFALSE;
1436
1437   TString detStr = detectors;
1438   TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1439   for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1440     AliModule* det = (AliModule*) detArray->At(iDet);
1441     if (!det || !det->IsActive()) continue;
1442     if (IsSelected(det->GetName(), detStr)) {
1443       AliInfo(Form("creating digits from hits for %s", det->GetName()));
1444       det->Hits2Digits();
1445     }
1446   }
1447
1448   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1449     AliError(Form("the following detectors were not found: %s", 
1450                   detStr.Data()));
1451     if (fStopOnError) return kFALSE;
1452   }
1453
1454   return kTRUE;
1455 }
1456
1457 //_____________________________________________________________________________
1458 Bool_t AliSimulation::WriteRawData(const char* detectors, 
1459                                    const char* fileName,
1460                                    Bool_t deleteIntermediateFiles,
1461                                    Bool_t selrawdata)
1462 {
1463 // convert the digits to raw data
1464 // First DDL raw data files for the given detectors are created.
1465 // If a file name is given, the DDL files are then converted to a DATE file.
1466 // If deleteIntermediateFiles is true, the DDL raw files are deleted 
1467 // afterwards.
1468 // If the file name has the extension ".root", the DATE file is converted
1469 // to a root file.
1470 // If deleteIntermediateFiles is true, the DATE file is deleted afterwards.
1471 // 'selrawdata' flag can be used to enable writing of detectors raw data
1472 // accoring to the trigger cluster.
1473
1474   AliCodeTimerAuto("",0)
1475   AliSysInfo::AddStamp("WriteRawData_Start");
1476   
1477   TString detStr = detectors;
1478   if (!WriteRawFiles(detStr.Data())) {
1479     if (fStopOnError) return kFALSE;
1480   }
1481   AliSysInfo::AddStamp("WriteRawFiles");
1482
1483   // run HLT simulation on simulated DDL raw files
1484   // and produce HLT ddl raw files to be included in date/root file
1485   // bugfix 2009-06-26: the decision whether to write HLT raw data
1486   // is taken in RunHLT. Here HLT always needs to be run in order to
1487   // create HLT digits, unless its switched off. This is due to the
1488   // special placement of the HLT between the generation of DDL files
1489   // and conversion to DATE/Root file.
1490   detStr.ReplaceAll("HLT", "");
1491   if (!fRunHLT.IsNull()) {
1492     if (!RunHLT()) {
1493       if (fStopOnError) return kFALSE;
1494     }
1495   }
1496   AliSysInfo::AddStamp("WriteRawData_RunHLT");
1497
1498   TString dateFileName(fileName);
1499   if (!dateFileName.IsNull()) {
1500     Bool_t rootOutput = dateFileName.EndsWith(".root");
1501     if (rootOutput) dateFileName += ".date";
1502     TString selDateFileName;
1503     if (selrawdata) {
1504       selDateFileName = "selected.";
1505       selDateFileName+= dateFileName;
1506     }
1507     if (!ConvertRawFilesToDate(dateFileName,selDateFileName)) {
1508       if (fStopOnError) return kFALSE;
1509     }
1510     AliSysInfo::AddStamp("ConvertRawFilesToDate");
1511     if (deleteIntermediateFiles) {
1512       AliRunLoader* runLoader = LoadRun("READ");
1513       if (runLoader) for (Int_t iEvent = 0; 
1514                           iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
1515         char command[256];
1516         snprintf(command, 256, "rm -r raw%d", iEvent);
1517         gSystem->Exec(command);
1518       }
1519       delete runLoader;
1520     }
1521
1522     if (rootOutput) {
1523       if (!ConvertDateToRoot(dateFileName, fileName)) {
1524         if (fStopOnError) return kFALSE;
1525       }
1526       AliSysInfo::AddStamp("ConvertDateToRoot");
1527       if (deleteIntermediateFiles) {
1528         gSystem->Unlink(dateFileName);
1529       }
1530       if (selrawdata) {
1531         TString selFileName = "selected.";
1532         selFileName        += fileName;
1533         if (!ConvertDateToRoot(selDateFileName, selFileName)) {
1534           if (fStopOnError) return kFALSE;
1535         }
1536         if (deleteIntermediateFiles) {
1537           gSystem->Unlink(selDateFileName);
1538         }
1539       }
1540     }
1541   }
1542
1543   return kTRUE;
1544 }
1545
1546 //_____________________________________________________________________________
1547 Bool_t AliSimulation::WriteRawFiles(const char* detectors)
1548 {
1549 // convert the digits to raw data DDL files
1550
1551   AliCodeTimerAuto("",0)
1552   
1553   AliRunLoader* runLoader = LoadRun("READ");
1554   if (!runLoader) return kFALSE;
1555
1556   // write raw data to DDL files
1557   for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
1558     AliInfo(Form("processing event %d", iEvent));
1559     runLoader->GetEvent(iEvent);
1560     TString baseDir = gSystem->WorkingDirectory();
1561     char dirName[256];
1562     snprintf(dirName, 256, "raw%d", iEvent);
1563     gSystem->MakeDirectory(dirName);
1564     if (!gSystem->ChangeDirectory(dirName)) {
1565       AliError(Form("couldn't change to directory %s", dirName));
1566       if (fStopOnError) return kFALSE; else continue;
1567     }
1568
1569     ofstream runNbFile(Form("run%u",runLoader->GetHeader()->GetRun()));
1570     runNbFile.close();
1571
1572     TString detStr = detectors;
1573     if (IsSelected("HLT", detStr)) {
1574       // Do nothing. "HLT" will be removed from detStr and HLT raw
1575       // data files are generated in RunHLT.
1576     }
1577
1578     TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1579     for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1580       AliModule* det = (AliModule*) detArray->At(iDet);
1581       if (!det || !det->IsActive()) continue;
1582       if (IsSelected(det->GetName(), detStr)) {
1583         AliInfo(Form("creating raw data from digits for %s", det->GetName()));
1584         det->Digits2Raw();
1585       }
1586     }
1587
1588     if (!WriteTriggerRawData())
1589       if (fStopOnError) return kFALSE;
1590
1591     gSystem->ChangeDirectory(baseDir);
1592     if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1593       AliError(Form("the following detectors were not found: %s", 
1594                     detStr.Data()));
1595       if (fStopOnError) return kFALSE;
1596     }
1597   }
1598
1599   delete runLoader;
1600   
1601   return kTRUE;
1602 }
1603
1604 //_____________________________________________________________________________
1605 Bool_t AliSimulation::ConvertRawFilesToDate(const char* dateFileName,
1606                                             const char* selDateFileName)
1607 {
1608 // convert raw data DDL files to a DATE file with the program "dateStream"
1609 // The second argument is not empty when the user decides to write
1610 // the detectors raw data according to the trigger cluster.
1611
1612   AliCodeTimerAuto("",0)
1613   
1614   char* path = gSystem->Which(gSystem->Getenv("PATH"), "dateStream");
1615   if (!path) {
1616     AliError("the program dateStream was not found");
1617     if (fStopOnError) return kFALSE;
1618   } else {
1619     delete[] path;
1620   }
1621
1622   AliRunLoader* runLoader = LoadRun("READ");
1623   if (!runLoader) return kFALSE;
1624
1625   AliInfo(Form("converting raw data DDL files to DATE file %s", dateFileName));
1626   Bool_t selrawdata = kFALSE;
1627   if (strcmp(selDateFileName,"") != 0) selrawdata = kTRUE;
1628
1629   char command[256];
1630   // Note the option -s. It is used in order to avoid
1631   // the generation of SOR/EOR events.
1632   snprintf(command, 256, "dateStream -c -s -D -o %s -# %d -C -run %d", 
1633           dateFileName, runLoader->GetNumberOfEvents(),runLoader->GetHeader()->GetRun());
1634   FILE* pipe = gSystem->OpenPipe(command, "w");
1635
1636   if (!pipe) {
1637     AliError(Form("Cannot execute command: %s",command));
1638     return kFALSE;
1639   }
1640
1641   Int_t selEvents = 0;
1642   for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
1643
1644     UInt_t detectorPattern = 0;
1645     runLoader->GetEvent(iEvent);
1646     if (!runLoader->LoadTrigger()) {
1647       AliCentralTrigger *aCTP = runLoader->GetTrigger();
1648       detectorPattern = aCTP->GetClusterMask();
1649       // Check if the event was triggered by CTP
1650       if (selrawdata) {
1651         if (aCTP->GetClassMask()) selEvents++;
1652       }
1653     }
1654     else {
1655       AliWarning("No trigger can be loaded! Some fields in the event header will be empty !");
1656       if (selrawdata) {
1657         AliWarning("No trigger can be loaded! Writing of selected raw data is abandoned !");
1658         selrawdata = kFALSE;
1659       }
1660     }
1661
1662     fprintf(pipe, "GDC DetectorPattern %u Timestamp %ld\n", detectorPattern, runLoader->GetHeader()->GetTimeStamp());
1663     Float_t ldc = 0;
1664     Int_t prevLDC = -1;
1665
1666     // loop over detectors and DDLs
1667     for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
1668       for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls(iDet); iDDL++) {
1669
1670         Int_t ddlID = AliDAQ::DdlID(iDet,iDDL);
1671         Int_t ldcID = Int_t(ldc + 0.0001);
1672         ldc += AliDAQ::NumberOfLdcs(iDet) / AliDAQ::NumberOfDdls(iDet);
1673
1674         char rawFileName[256];
1675         snprintf(rawFileName, 256, "raw%d/%s", 
1676                 iEvent, AliDAQ::DdlFileName(iDet,iDDL));
1677
1678         // check existence and size of raw data file
1679         FILE* file = fopen(rawFileName, "rb");
1680         if (!file) continue;
1681         fseek(file, 0, SEEK_END);
1682         unsigned long size = ftell(file);
1683         fclose(file);
1684         if (!size) continue;
1685
1686         if (ldcID != prevLDC) {
1687           fprintf(pipe, " LDC Id %d\n", ldcID);
1688           prevLDC = ldcID;
1689         }
1690         fprintf(pipe, "  Equipment Id %d Payload %s\n", ddlID, rawFileName);
1691       }
1692     }
1693   }
1694
1695   Int_t result = gSystem->ClosePipe(pipe);
1696
1697   if (!(selrawdata && selEvents > 0)) {
1698     delete runLoader;
1699     return (result == 0);
1700   }
1701
1702   AliInfo(Form("converting selected by trigger cluster raw data DDL files to DATE file %s", selDateFileName));
1703   
1704   snprintf(command, 256, "dateStream -c -s -D -o %s -# %d -C -run %d", 
1705           selDateFileName,selEvents,runLoader->GetHeader()->GetRun());
1706   FILE* pipe2 = gSystem->OpenPipe(command, "w");
1707
1708   for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
1709
1710     // Get the trigger decision and cluster
1711     UInt_t detectorPattern = 0;
1712     TString detClust;
1713     runLoader->GetEvent(iEvent);
1714     if (!runLoader->LoadTrigger()) {
1715       AliCentralTrigger *aCTP = runLoader->GetTrigger();
1716       if (aCTP->GetClassMask() == 0) continue;
1717       detectorPattern = aCTP->GetClusterMask();
1718       detClust = AliDAQ::ListOfTriggeredDetectors(detectorPattern);
1719       AliInfo(Form("List of detectors to be read out: %s",detClust.Data()));
1720     }
1721
1722     fprintf(pipe2, "GDC DetectorPattern %u Timestamp %ld\n", detectorPattern, runLoader->GetHeader()->GetTimeStamp());
1723     Float_t ldc = 0;
1724     Int_t prevLDC = -1;
1725
1726     // loop over detectors and DDLs
1727     for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
1728       // Write only raw data from detectors that
1729       // are contained in the trigger cluster(s)
1730       if (!IsSelected(AliDAQ::DetectorName(iDet),detClust)) continue;
1731
1732       for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls(iDet); iDDL++) {
1733
1734         Int_t ddlID = AliDAQ::DdlID(iDet,iDDL);
1735         Int_t ldcID = Int_t(ldc + 0.0001);
1736         ldc += AliDAQ::NumberOfLdcs(iDet) / AliDAQ::NumberOfDdls(iDet);
1737
1738         char rawFileName[256];
1739         snprintf(rawFileName, 256, "raw%d/%s", 
1740                 iEvent, AliDAQ::DdlFileName(iDet,iDDL));
1741
1742         // check existence and size of raw data file
1743         FILE* file = fopen(rawFileName, "rb");
1744         if (!file) continue;
1745         fseek(file, 0, SEEK_END);
1746         unsigned long size = ftell(file);
1747         fclose(file);
1748         if (!size) continue;
1749
1750         if (ldcID != prevLDC) {
1751           fprintf(pipe2, " LDC Id %d\n", ldcID);
1752           prevLDC = ldcID;
1753         }
1754         fprintf(pipe2, "  Equipment Id %d Payload %s\n", ddlID, rawFileName);
1755       }
1756     }
1757   }
1758
1759   Int_t result2 = gSystem->ClosePipe(pipe2);
1760
1761   delete runLoader;
1762   return ((result == 0) && (result2 == 0));
1763 }
1764
1765 //_____________________________________________________________________________
1766 Bool_t AliSimulation::ConvertDateToRoot(const char* dateFileName,
1767                                         const char* rootFileName)
1768 {
1769 // convert a DATE file to a root file with the program "alimdc"
1770
1771   // ALIMDC setup
1772   const Int_t kDBSize = 2000000000;
1773   const Int_t kTagDBSize = 1000000000;
1774   const Bool_t kFilter = kFALSE;
1775   const Int_t kCompression = 1;
1776
1777   char* path = gSystem->Which(gSystem->Getenv("PATH"), "alimdc");
1778   if (!path) {
1779     AliError("the program alimdc was not found");
1780     if (fStopOnError) return kFALSE;
1781   } else {
1782     delete[] path;
1783   }
1784
1785   AliInfo(Form("converting DATE file %s to root file %s", 
1786                dateFileName, rootFileName));
1787
1788   const char* rawDBFS[2] = { "/tmp/mdc1", "/tmp/mdc2" };
1789   const char* tagDBFS    = "/tmp/mdc1/tags";
1790
1791   // User defined file system locations
1792   if (gSystem->Getenv("ALIMDC_RAWDB1")) 
1793     rawDBFS[0] = gSystem->Getenv("ALIMDC_RAWDB1");
1794   if (gSystem->Getenv("ALIMDC_RAWDB2")) 
1795     rawDBFS[1] = gSystem->Getenv("ALIMDC_RAWDB2");
1796   if (gSystem->Getenv("ALIMDC_TAGDB")) 
1797     tagDBFS = gSystem->Getenv("ALIMDC_TAGDB");
1798
1799   gSystem->Exec(Form("rm -rf %s",rawDBFS[0]));
1800   gSystem->Exec(Form("rm -rf %s",rawDBFS[1]));
1801   gSystem->Exec(Form("rm -rf %s",tagDBFS));
1802
1803   gSystem->Exec(Form("mkdir %s",rawDBFS[0]));
1804   gSystem->Exec(Form("mkdir %s",rawDBFS[1]));
1805   gSystem->Exec(Form("mkdir %s",tagDBFS));
1806
1807   Int_t result = gSystem->Exec(Form("alimdc %d %d %d %d %s", 
1808                                     kDBSize, kTagDBSize, kFilter, kCompression, dateFileName));
1809   gSystem->Exec(Form("mv %s/*.root %s", rawDBFS[0], rootFileName));
1810
1811   gSystem->Exec(Form("rm -rf %s",rawDBFS[0]));
1812   gSystem->Exec(Form("rm -rf %s",rawDBFS[1]));
1813   gSystem->Exec(Form("rm -rf %s",tagDBFS));
1814
1815   return (result == 0);
1816 }
1817
1818
1819 //_____________________________________________________________________________
1820 AliRunLoader* AliSimulation::LoadRun(const char* mode) const
1821 {
1822 // delete existing run loaders, open a new one and load gAlice
1823
1824   delete AliRunLoader::Instance();
1825   AliRunLoader* runLoader = 
1826     AliRunLoader::Open(fGAliceFileName.Data(), 
1827                        AliConfig::GetDefaultEventFolderName(), mode);
1828   if (!runLoader) {
1829     AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
1830     return NULL;
1831   }
1832   runLoader->LoadgAlice();
1833   runLoader->LoadHeader();
1834   gAlice = runLoader->GetAliRun();
1835   if (!gAlice) {
1836     AliError(Form("no gAlice object found in file %s", 
1837                   fGAliceFileName.Data()));
1838     return NULL;
1839   }
1840   return runLoader;
1841 }
1842
1843 //_____________________________________________________________________________
1844 Int_t AliSimulation::GetNSignalPerBkgrd(Int_t nEvents) const
1845 {
1846 // get or calculate the number of signal events per background event
1847
1848   if (!fBkgrdFileNames) return 1;
1849   Int_t nBkgrdFiles = fBkgrdFileNames->GetEntriesFast();
1850   if (nBkgrdFiles == 0) return 1;
1851
1852   // get the number of signal events
1853   if (nEvents <= 0) {
1854     AliRunLoader* runLoader = 
1855         AliRunLoader::Open(fGAliceFileName.Data(), "SIGNAL");
1856     if (!runLoader) return 1;
1857     
1858     nEvents = runLoader->GetNumberOfEvents();
1859     delete runLoader;
1860   }
1861
1862   Int_t result = 0;
1863   for (Int_t iBkgrdFile = 0; iBkgrdFile < nBkgrdFiles; iBkgrdFile++) {
1864     // get the number of background events
1865     const char* fileName = ((TObjString*)
1866                             (fBkgrdFileNames->At(iBkgrdFile)))->GetName();
1867     AliRunLoader* runLoader =
1868       AliRunLoader::Open(fileName, "BKGRD");
1869     if (!runLoader) continue;
1870     Int_t nBkgrdEvents = runLoader->GetNumberOfEvents();
1871     delete runLoader;
1872   
1873     // get or calculate the number of signal per background events
1874     Int_t nSignalPerBkgrd = fBkgrdFileNames->At(iBkgrdFile)->GetUniqueID();
1875     if (nSignalPerBkgrd <= 0) {
1876       nSignalPerBkgrd = (nEvents-1) / nBkgrdEvents + 1;
1877     } else if (result && (result != nSignalPerBkgrd)) {
1878       AliInfo(Form("the number of signal events per background event "
1879                    "will be changed from %d to %d for stream %d", 
1880                    nSignalPerBkgrd, result, iBkgrdFile+1));
1881       nSignalPerBkgrd = result;
1882     }
1883
1884     if (!result) result = nSignalPerBkgrd;
1885     if (nSignalPerBkgrd * nBkgrdEvents < nEvents) {
1886       AliWarning(Form("not enough background events (%d) for %d signal events "
1887                       "using %d signal per background events for stream %d",
1888                       nBkgrdEvents, nEvents, nSignalPerBkgrd, iBkgrdFile+1));
1889     }
1890   }
1891
1892   return result;
1893 }
1894
1895 //_____________________________________________________________________________
1896 Bool_t AliSimulation::IsSelected(TString detName, TString& detectors) const
1897 {
1898 // check whether detName is contained in detectors
1899 // if yes, it is removed from detectors
1900
1901   // check if all detectors are selected
1902   if ((detectors.CompareTo("ALL") == 0) ||
1903       detectors.BeginsWith("ALL ") ||
1904       detectors.EndsWith(" ALL") ||
1905       detectors.Contains(" ALL ")) {
1906     detectors = "ALL";
1907     return kTRUE;
1908   }
1909
1910   // search for the given detector
1911   Bool_t result = kFALSE;
1912   if ((detectors.CompareTo(detName) == 0) ||
1913       detectors.BeginsWith(detName+" ") ||
1914       detectors.EndsWith(" "+detName) ||
1915       detectors.Contains(" "+detName+" ")) {
1916     detectors.ReplaceAll(detName, "");
1917     result = kTRUE;
1918   }
1919
1920   // clean up the detectors string
1921   while (detectors.Contains("  ")) detectors.ReplaceAll("  ", " ");
1922   while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
1923   while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
1924
1925   return result;
1926 }
1927
1928 //_____________________________________________________________________________
1929 Int_t AliSimulation::ConvertRaw2SDigits(const char* rawDirectory, const char* esdFileName, Int_t N, Int_t nSkip)
1930 {
1931 //
1932 // Steering routine  to convert raw data in directory rawDirectory/ to fake SDigits. 
1933 // These can be used for embedding of MC tracks into RAW data using the standard 
1934 // merging procedure.
1935 //
1936 // If an ESD file is given the reconstructed vertex is taken from it and stored in the event header.
1937 //
1938   if (!gAlice) {
1939     AliError("no gAlice object. Restart aliroot and try again.");
1940     return kFALSE;
1941   }
1942   if (gAlice->Modules()->GetEntries() > 0) {
1943     AliError("gAlice was already run. Restart aliroot and try again.");
1944     return kFALSE;
1945   }
1946   
1947   AliInfo(Form("initializing gAlice with config file %s",fConfigFileName.Data()));
1948   
1949   gAlice->Announce();
1950   
1951   gROOT->LoadMacro(fConfigFileName.Data());
1952   gInterpreter->ProcessLine(gAlice->GetConfigFunction());
1953   
1954   if(AliCDBManager::Instance()->GetRun() >= 0) { 
1955         SetRunNumber(AliCDBManager::Instance()->GetRun());
1956   } else {
1957         AliWarning("Run number not initialized!!");
1958   }
1959   
1960    AliRunLoader::Instance()->CdGAFile();
1961     
1962    AliPDG::AddParticlesToPdgDataBase();  
1963
1964    gMC->SetMagField(TGeoGlobalMagField::Instance()->GetField());
1965    
1966    gAlice->GetMCApp()->Init();
1967
1968    //Must be here because some MCs (G4) adds detectors here and not in Config.C
1969    gAlice->InitLoaders();
1970    AliRunLoader::Instance()->MakeTree("E");
1971    AliRunLoader::Instance()->LoadKinematics("RECREATE");
1972    AliRunLoader::Instance()->LoadTrackRefs("RECREATE");
1973    AliRunLoader::Instance()->LoadHits("all","RECREATE");
1974
1975    //
1976    // Save stuff at the beginning of the file to avoid file corruption
1977    AliRunLoader::Instance()->CdGAFile();
1978    gAlice->Write();
1979 //
1980 //  Initialize CDB     
1981     InitCDB();
1982     //AliCDBManager* man = AliCDBManager::Instance();
1983     //man->SetRun(0); // Should this come from rawdata header ?
1984     
1985     Int_t iDet;
1986     //
1987     // Get the runloader
1988     AliRunLoader* runLoader = AliRunLoader::Instance();
1989     //
1990     // Open esd file if available
1991     TFile* esdFile = 0;
1992     TTree* treeESD = 0;
1993     AliESDEvent* esd = 0;
1994     if (esdFileName && (strlen(esdFileName)>0)) {
1995       esdFile = TFile::Open(esdFileName);
1996       if (esdFile) {
1997         esd = new AliESDEvent();
1998         esdFile->GetObject("esdTree", treeESD);
1999                   if (treeESD) {
2000                           esd->ReadFromTree(treeESD);
2001                           if (nSkip>0) {
2002                                   AliInfo(Form("Asking to skip first %d ESDs events",nSkip));
2003                           } else {
2004                                   nSkip=0;
2005                           }
2006                   }
2007       }
2008     }
2009
2010     //
2011     // Create the RawReader
2012     TString fileName(rawDirectory);
2013     AliRawReader* rawReader = AliRawReader::Create(fileName.Data());
2014     if (!rawReader) return (kFALSE);
2015     
2016 //     if (!fEquipIdMap.IsNull() && fRawReader)
2017 //       fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
2018     //
2019     // Get list of detectors
2020     TObjArray* detArray = runLoader->GetAliRun()->Detectors();
2021     //
2022     // Get Header
2023     AliHeader* header = runLoader->GetHeader();
2024     // Event loop
2025     Int_t nev = 0;
2026     while(kTRUE) {
2027         if (!(rawReader->NextEvent())) break;
2028         runLoader->SetEventNumber(nev);
2029         runLoader->GetHeader()->Reset(rawReader->GetRunNumber(), 
2030                                       nev, nev);
2031         runLoader->GetEvent(nev);
2032         AliInfo(Form("We are at event %d",nev));
2033         //
2034         // Detector loop
2035         TString detStr = fMakeSDigits;
2036         for (iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
2037             AliModule* det = (AliModule*) detArray->At(iDet);
2038             if (!det || !det->IsActive()) continue;
2039             if (IsSelected(det->GetName(), detStr)) {
2040               AliInfo(Form("Calling Raw2SDigits for %s", det->GetName()));
2041               det->Raw2SDigits(rawReader);
2042               rawReader->Reset();
2043             }
2044         } // detectors
2045         
2046
2047         //
2048         //  If ESD information available obtain reconstructed vertex and store in header.
2049         if (treeESD) {
2050                 AliInfo(Form("Selected event %d correspond to event %d in raw and to %d in esd",nev,rawReader->GetEventIndex(),nSkip+rawReader->GetEventIndex()));
2051             treeESD->GetEvent(nSkip+rawReader->GetEventIndex());
2052             const AliESDVertex* esdVertex = esd->GetPrimaryVertex();
2053             Double_t position[3];
2054             esdVertex->GetXYZ(position);
2055             AliGenEventHeader* mcHeader = new  AliGenEventHeader("ESD");
2056             TArrayF mcV;
2057             mcV.Set(3);
2058             for (Int_t i = 0; i < 3; i++) mcV[i] = position[i];
2059             mcHeader->SetPrimaryVertex(mcV);
2060             header->Reset(0,nev);
2061             header->SetGenEventHeader(mcHeader);
2062             AliInfo(Form("***** Saved vertex %f %f %f \n", position[0], position[1], position[2]));
2063         }
2064 //
2065 //      Finish the event
2066         runLoader->TreeE()->Fill();
2067         AliInfo(Form("Finished event %d",nev));
2068         nev++;
2069         if (N>0&&nev>=N)
2070           break;
2071     } // events
2072  
2073     delete rawReader;
2074 //
2075 //  Finish the run 
2076     runLoader->CdGAFile();
2077     runLoader->WriteHeader("OVERWRITE");
2078     runLoader->WriteRunLoader();
2079
2080     return nev;
2081 }
2082
2083 //_____________________________________________________________________________
2084 void AliSimulation::FinishRun()
2085 {
2086   //
2087   // Called at the end of the run.
2088   //
2089
2090   if(IsLegoRun()) 
2091    {
2092     AliDebug(1, "Finish Lego");
2093     AliRunLoader::Instance()->CdGAFile();
2094     fLego->FinishRun();
2095    }
2096   
2097   // Clean detector information
2098   TIter next(gAlice->Modules());
2099   AliModule *detector;
2100   while((detector = dynamic_cast<AliModule*>(next()))) {
2101     AliDebug(2, Form("%s->FinishRun()", detector->GetName()));
2102     detector->FinishRun();
2103   }
2104   
2105   AliDebug(1, "AliRunLoader::Instance()->WriteHeader(OVERWRITE)");
2106   AliRunLoader::Instance()->WriteHeader("OVERWRITE");
2107
2108   // Write AliRun info and all detectors parameters
2109   AliRunLoader::Instance()->CdGAFile();
2110   gAlice->Write(0,TObject::kOverwrite);//write AliRun
2111   AliRunLoader::Instance()->Write(0,TObject::kOverwrite);//write RunLoader itself
2112   
2113   if(gAlice->GetMCApp()) gAlice->GetMCApp()->FinishRun();  
2114   AliRunLoader::Instance()->Synchronize();
2115 }
2116
2117 //_____________________________________________________________________________
2118 Int_t AliSimulation::GetDetIndex(const char* detector)
2119 {
2120   // return the detector index corresponding to detector
2121   Int_t index = -1 ; 
2122   for (index = 0; index < fgkNDetectors ; index++) {
2123     if ( strcmp(detector, fgkDetectorName[index]) == 0 )
2124           break ; 
2125   }     
2126   return index ; 
2127 }
2128
2129 //_____________________________________________________________________________
2130 Bool_t AliSimulation::CreateHLT()
2131 {
2132   // Init the HLT simulation.
2133   // The function  loads the library and creates the instance of AliHLTSimulation.
2134   // the main reason for the decoupled creation is to set the transient OCDB
2135   // objects before the OCDB is locked
2136
2137   // load the library dynamically
2138   gSystem->Load(ALIHLTSIMULATION_LIBRARY);
2139
2140   // check for the library version
2141   AliHLTSimulationGetLibraryVersion_t fctVersion=(AliHLTSimulationGetLibraryVersion_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_GET_LIBRARY_VERSION));
2142   if (!fctVersion) {
2143     AliError(Form("can not load library %s", ALIHLTSIMULATION_LIBRARY));
2144     return kFALSE;
2145   }
2146   if (fctVersion()!= ALIHLTSIMULATION_LIBRARY_VERSION) {
2147     AliWarning(Form("%s version does not match: compiled for version %d, loaded %d", ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_LIBRARY_VERSION, fctVersion()));
2148   }
2149
2150   // print compile info
2151   typedef void (*CompileInfo)( const char*& date, const char*& time);
2152   CompileInfo fctInfo=(CompileInfo)gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, "CompileInfo");
2153   if (fctInfo) {
2154     const char* date="";
2155     const char* time="";
2156     (*fctInfo)(date, time);
2157     if (!date) date="unknown";
2158     if (!time) time="unknown";
2159     AliInfo(Form("%s build on %s (%s)", ALIHLTSIMULATION_LIBRARY, date, time));
2160   } else {
2161     AliInfo(Form("no build info available for %s", ALIHLTSIMULATION_LIBRARY));
2162   }
2163
2164   // create instance of the HLT simulation
2165   AliHLTSimulationCreateInstance_t fctCreate=(AliHLTSimulationCreateInstance_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_CREATE_INSTANCE));
2166   if (fctCreate==NULL || (fpHLT=(fctCreate()))==NULL) {
2167     AliError(Form("can not create instance of HLT simulation (creator %p)", fctCreate));
2168     return kFALSE;    
2169   }
2170
2171   TString specObjects;
2172   for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
2173     if (specObjects.Length()>0) specObjects+=" ";
2174     specObjects+=fSpecCDBUri[i]->GetName();
2175   }
2176
2177   AliHLTSimulationSetup_t fctSetup=(AliHLTSimulationSetup_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_SETUP));
2178   if (fctSetup==NULL || fctSetup(fpHLT, this, specObjects.Data())<0) {
2179     AliWarning(Form("failed to setup HLT simulation (function %p)", fctSetup));
2180   }
2181
2182   return kTRUE;
2183 }
2184
2185 //_____________________________________________________________________________
2186 Bool_t AliSimulation::RunHLT()
2187 {
2188   // Run the HLT simulation
2189   // HLT simulation is implemented in HLT/sim/AliHLTSimulation
2190   // Disabled if fRunHLT is empty, default vaule is "default".
2191   // AliSimulation::SetRunHLT can be used to set the options for HLT simulation
2192   // The default simulation depends on the HLT component libraries and their
2193   // corresponding agents which define components and chains to run. See
2194   // http://web.ift.uib.no/~kjeks/doc/alice-hlt-current/
2195   // http://web.ift.uib.no/~kjeks/doc/alice-hlt-current/classAliHLTModuleAgent.html
2196   //
2197   // The libraries to be loaded can be specified as an option.
2198   // <pre>
2199   // AliSimulation sim;
2200   // sim.SetRunHLT("libAliHLTSample.so");
2201   // </pre>
2202   // will only load <tt>libAliHLTSample.so</tt>
2203
2204   // Other available options:
2205   // \li loglevel=<i>level</i> <br>
2206   //     logging level for this processing
2207   // \li alilog=off
2208   //     disable redirection of log messages to AliLog class
2209   // \li config=<i>macro</i>
2210   //     configuration macro
2211   // \li chains=<i>configuration</i>
2212   //     comma separated list of configurations to be run during simulation
2213   // \li rawfile=<i>file</i>
2214   //     source for the RawReader to be created, the default is <i>./</i> if
2215   //     raw data is simulated
2216
2217   int iResult=0;
2218
2219   if (!fpHLT && !CreateHLT()) {
2220     return kFALSE;
2221   }
2222   AliHLTSimulation* pHLT=fpHLT;
2223
2224   AliRunLoader* pRunLoader = LoadRun("READ");
2225   if (!pRunLoader) return kFALSE;
2226
2227   // initialize CDB storage, run number, set CDB lock
2228   // thats for the case of running HLT simulation without all the other steps
2229   // multiple calls are handled by the function, so we can just call
2230   InitCDB();
2231   if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
2232   SetCDBLock();
2233   
2234   // init the HLT simulation
2235   TString options;
2236   if (fRunHLT.CompareTo("default")!=0) options=fRunHLT;
2237   TString detStr = fWriteRawData;
2238   if (!IsSelected("HLT", detStr)) {
2239     options+=" writerawfiles=";
2240   } else {
2241     options+=" writerawfiles=HLT";
2242   }
2243
2244   if (!detStr.IsNull() && !options.Contains("rawfile=")) {
2245     // as a matter of fact, HLT will run reconstruction and needs the RawReader
2246     // in order to get detector data. By default, RawReaderFile is used to read
2247     // the already simulated ddl files. Date and Root files from the raw data
2248     // are generated after the HLT simulation.
2249     options+=" rawfile=./";
2250   }
2251
2252   AliHLTSimulationInit_t fctInit=(AliHLTSimulationInit_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_INIT));
2253   if (fctInit==NULL || (iResult=(fctInit(pHLT, pRunLoader, options.Data())))<0) {
2254     AliError(Form("can not init HLT simulation: error %d (init %p)", iResult, fctInit));
2255   } else {
2256     // run the HLT simulation
2257     AliHLTSimulationRun_t fctRun=(AliHLTSimulationRun_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_RUN));
2258     if (fctRun==NULL || (iResult=(fctRun(pHLT, pRunLoader)))<0) {
2259       AliError(Form("can not run HLT simulation: error %d (run %p)", iResult, fctRun));
2260     }
2261   }
2262
2263   // delete the instance
2264   AliHLTSimulationDeleteInstance_t fctDelete=(AliHLTSimulationDeleteInstance_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_DELETE_INSTANCE));
2265   if (fctDelete==NULL || fctDelete(pHLT)<0) {
2266     AliError(Form("can not delete instance of HLT simulation (creator %p)", fctDelete));
2267   }
2268   pHLT=NULL;
2269
2270   return iResult>=0?kTRUE:kFALSE;
2271 }
2272
2273 //_____________________________________________________________________________
2274 Bool_t AliSimulation::RunQA()
2275 {
2276         // run the QA on summable hits, digits or digits
2277         
2278     //if(!gAlice) return kFALSE;
2279         AliQAManager::QAManager()->SetRunLoader(AliRunLoader::Instance()) ;
2280
2281         TString detectorsw("") ;  
2282         Bool_t rv = kTRUE ; 
2283   AliQAManager::QAManager()->SetEventSpecie(fEventSpecie) ;
2284         detectorsw = AliQAManager::QAManager()->Run(fQADetectors.Data()) ; 
2285         if ( detectorsw.IsNull() ) 
2286                 rv = kFALSE ; 
2287         return rv ; 
2288 }
2289
2290 //_____________________________________________________________________________
2291 Bool_t AliSimulation::SetRunQA(TString detAndAction) 
2292 {
2293         // Allows to run QA for a selected set of detectors
2294         // and a selected set of tasks among HITS, SDIGITS and DIGITS
2295         // all selected detectors run the same selected tasks
2296         
2297         if (!detAndAction.Contains(":")) {
2298                 AliError( Form("%s is a wrong syntax, use \"DetectorList:ActionList\" \n", detAndAction.Data()) ) ;
2299                 fRunQA = kFALSE ;
2300                 return kFALSE ;                 
2301         }
2302         Int_t colon = detAndAction.Index(":") ; 
2303         fQADetectors = detAndAction(0, colon) ; 
2304         if (fQADetectors.Contains("ALL") ){
2305     TString tmp = Form("%s %s", fMakeDigits.Data(), fMakeDigitsFromHits.Data()) ; 
2306     Int_t minus = fQADetectors.Last('-') ; 
2307     TString toKeep = Form("%s %s", fMakeDigits.Data(), fMakeDigitsFromHits.Data()) ; 
2308     TString toRemove("") ;
2309     while (minus >= 0) {
2310       toRemove = fQADetectors(minus+1, fQADetectors.Length()) ; 
2311       toRemove = toRemove.Strip() ; 
2312       toKeep.ReplaceAll(toRemove, "") ; 
2313       fQADetectors.ReplaceAll(Form("-%s", toRemove.Data()), "") ; 
2314       minus = fQADetectors.Last('-') ; 
2315     }
2316     fQADetectors = toKeep ; 
2317   }
2318   fQATasks   = detAndAction(colon+1, detAndAction.Sizeof() ) ; 
2319         if (fQATasks.Contains("ALL") ) {
2320                 fQATasks = Form("%d %d %d", AliQAv1::kHITS, AliQAv1::kSDIGITS, AliQAv1::kDIGITS) ; 
2321         } else {
2322                 fQATasks.ToUpper() ; 
2323                 TString tempo("") ; 
2324                 if ( fQATasks.Contains("HIT") ) 
2325                         tempo = Form("%d ", AliQAv1::kHITS) ; 
2326                 if ( fQATasks.Contains("SDIGIT") ) 
2327                         tempo += Form("%d ", AliQAv1::kSDIGITS) ; 
2328                 if ( fQATasks.Contains("DIGIT") ) 
2329                         tempo += Form("%d ", AliQAv1::kDIGITS) ; 
2330                 fQATasks = tempo ; 
2331                 if (fQATasks.IsNull()) {
2332                         AliInfo("No QA requested\n")  ;
2333                         fRunQA = kFALSE ;
2334                         return kTRUE ; 
2335                 }
2336         }       
2337         TString tempo(fQATasks) ; 
2338     tempo.ReplaceAll(Form("%d", AliQAv1::kHITS), AliQAv1::GetTaskName(AliQAv1::kHITS))  ;
2339     tempo.ReplaceAll(Form("%d", AliQAv1::kSDIGITS), AliQAv1::GetTaskName(AliQAv1::kSDIGITS)) ;  
2340     tempo.ReplaceAll(Form("%d", AliQAv1::kDIGITS), AliQAv1::GetTaskName(AliQAv1::kDIGITS)) ;    
2341         AliInfo( Form("QA will be done on \"%s\" for \"%s\"\n", fQADetectors.Data(), tempo.Data()) ) ;  
2342         fRunQA = kTRUE ;
2343         AliQAManager::QAManager()->SetActiveDetectors(fQADetectors) ; 
2344         AliQAManager::QAManager()->SetTasks(fQATasks) ; 
2345   for (Int_t det = 0 ; det < AliQAv1::kNDET ; det++) 
2346     AliQAManager::QAManager()->SetWriteExpert(AliQAv1::DETECTORINDEX_t(det)) ;
2347   
2348         return kTRUE; 
2349
2350
2351 //_____________________________________________________________________________
2352 void AliSimulation::ProcessEnvironmentVars()
2353 {
2354 // Extract run number and random generator seed from env variables
2355
2356     AliInfo("Processing environment variables");
2357     
2358     // Random Number seed
2359     
2360     // first check that seed is not already set
2361     if (fSeed == 0) {
2362         if (gSystem->Getenv("CONFIG_SEED")) {
2363                 fSeed = atoi(gSystem->Getenv("CONFIG_SEED"));
2364         }
2365     } else {
2366         if (gSystem->Getenv("CONFIG_SEED")) {
2367                 AliInfo(Form("Seed for random number generation already set (%d)"
2368                              ": CONFIG_SEED variable ignored!", fSeed));
2369         }
2370     }
2371    
2372     AliInfo(Form("Seed for random number generation = %d ", fSeed)); 
2373
2374     // Run Number
2375     
2376     // first check that run number is not already set
2377     if(fRun < 0) {    
2378         if (gSystem->Getenv("DC_RUN")) {
2379                 fRun = atoi(gSystem->Getenv("DC_RUN"));
2380         }
2381     } else {
2382         if (gSystem->Getenv("DC_RUN")) {
2383                 AliInfo(Form("Run number already set (%d): DC_RUN variable ignored!", fRun));
2384         }
2385     }
2386     
2387     AliInfo(Form("Run number = %d", fRun)); 
2388 }
2389
2390 //---------------------------------------------------------------------
2391 void AliSimulation::WriteGRPEntry()
2392 {
2393   // Get the necessary information from galice (generator, trigger etc) and
2394   // write a GRP entry corresponding to the settings in the Config.C used
2395   // note that Hall probes and Cavern and Surface Atmos pressures are not simulated.
2396
2397
2398   AliInfo("Writing global run parameters entry into the OCDB");
2399
2400   AliGRPObject* grpObj = new AliGRPObject();
2401
2402   grpObj->SetRunType("PHYSICS");
2403   grpObj->SetTimeStart(fTimeStart);
2404   grpObj->SetTimeEnd(fTimeEnd); 
2405   grpObj->SetBeamEnergyIsSqrtSHalfGeV(); // new format of GRP: store sqrt(s)/2 in GeV
2406
2407   const AliGenerator *gen = gAlice->GetMCApp()->Generator();
2408   Int_t a = 0;
2409   Int_t z = 0;
2410
2411   if (gen) {
2412     TString projectile;
2413     gen->GetProjectile(projectile,a,z);
2414     TString target;
2415     gen->GetTarget(target,a,z);
2416     TString beamType = projectile + "-" + target;
2417     beamType.ReplaceAll(" ","");
2418     if (!beamType.CompareTo("-")) {
2419       grpObj->SetBeamType("UNKNOWN");
2420       grpObj->SetBeamEnergy(gen->GetEnergyCMS()/2);
2421     }
2422     else {
2423       grpObj->SetBeamType(beamType);
2424       if (z != 0) {
2425           grpObj->SetBeamEnergy(gen->GetEnergyCMS()/2 * a / z);
2426       } else {
2427           grpObj->SetBeamEnergy(gen->GetEnergyCMS()/2 );
2428       }
2429       // Heavy ion run, the event specie is set to kHighMult
2430       fEventSpecie = AliRecoParam::kHighMult;
2431       if ((strcmp(beamType,"p-p") == 0) ||
2432           (strcmp(beamType,"p-")  == 0) ||
2433           (strcmp(beamType,"-p")  == 0) ||
2434           (strcmp(beamType,"P-P") == 0) ||
2435           (strcmp(beamType,"P-")  == 0) ||
2436           (strcmp(beamType,"-P")  == 0)) {
2437         // Proton run, the event specie is set to kLowMult
2438         fEventSpecie = AliRecoParam::kLowMult;
2439       } 
2440     }
2441   } else {
2442     AliWarning("Unknown beam type and energy! Setting energy to 0");
2443     grpObj->SetBeamEnergy(0);
2444     grpObj->SetBeamType("UNKNOWN");
2445   }
2446
2447   UInt_t detectorPattern  = 0;
2448   Int_t nDets = 0;
2449   TObjArray *detArray = gAlice->Detectors();
2450   for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors-1; iDet++) {
2451     if (detArray->FindObject(AliDAQ::OfflineModuleName(iDet))) {
2452       AliDebug(1, Form("Detector #%d found: %s", iDet, AliDAQ::OfflineModuleName(iDet)));
2453       detectorPattern |= (1 << iDet);
2454       nDets++;
2455     }
2456   }
2457   // CTP
2458   if (!fTriggerConfig.IsNull())
2459     detectorPattern |= (1 << AliDAQ::DetectorID("TRG"));
2460
2461   // HLT
2462   if (!fRunHLT.IsNull())
2463     detectorPattern |= (1 << AliDAQ::kHLTId);
2464
2465   grpObj->SetNumberOfDetectors((Char_t)nDets);
2466   grpObj->SetDetectorMask((Int_t)detectorPattern);
2467   grpObj->SetLHCPeriod("LHC08c");
2468   grpObj->SetLHCState("STABLE_BEAMS");
2469   //
2470   AliMagF *field = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
2471   Float_t solenoidField = field ? TMath::Abs(field->SolenoidField()) : 0;
2472
2473   Float_t factorSol     = field ? field->GetFactorSol() : 0;
2474   Float_t currentSol    = TMath::Abs(factorSol)>1E-6 ? 
2475     TMath::Nint(TMath::Abs(solenoidField/factorSol))/5.*30000.*TMath::Abs(factorSol) : 0;
2476   //
2477   Float_t factorDip     = field ? field->GetFactorDip() : 0;
2478   Float_t currentDip    = 6000.*TMath::Abs(factorDip);
2479   //
2480   grpObj->SetL3Current(currentSol,(AliGRPObject::Stats)0);
2481   grpObj->SetDipoleCurrent(currentDip,(AliGRPObject::Stats)0);  
2482   grpObj->SetL3Polarity(factorSol>0 ? 0:1);  
2483   grpObj->SetDipolePolarity(factorDip>0 ? 0:1);
2484   if (field) grpObj->SetUniformBMap(field->IsUniform()); // for special MC with k5kGUniform map
2485   grpObj->SetPolarityConventionLHC();                    // LHC convention +/+ current -> -/- field main components
2486   //
2487   grpObj->SetCavernTemperature(0,(AliGRPObject::Stats)0);
2488   
2489   //grpMap->Add(new TObjString("fCavernPressure"),new TObjString("0")); ---> not inserted in simulation with the new object, since it is now an AliDCSSensor
2490
2491   // Now store the entry in OCDB
2492   AliCDBManager* man = AliCDBManager::Instance();
2493   
2494   man->SetLock(0, fKey);
2495   
2496   AliCDBStorage* sto = man->GetStorage(fGRPWriteLocation.Data());
2497   
2498
2499   AliCDBId id("GRP/GRP/Data", man->GetRun(), man->GetRun(), 1, 1);
2500   AliCDBMetaData *metadata= new AliCDBMetaData();
2501
2502   metadata->SetResponsible("alice-off@cern.ch");
2503   metadata->SetComment("Automatically produced GRP entry for Monte Carlo");
2504  
2505   sto->Put(grpObj,id,metadata);
2506   man->SetLock(1, fKey);
2507 }
2508
2509 //_____________________________________________________________________________
2510 time_t AliSimulation::GenerateTimeStamp() const
2511 {
2512   // Generate event time-stamp according to
2513   // SOR/EOR time from GRP
2514   if (fUseTimeStampFromCDB)
2515     return fTimeStart + gRandom->Integer(fTimeEnd-fTimeStart);
2516   else
2517     return 0;
2518 }