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