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