STEER/AliSimulation.cxx

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