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