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 <TVirtualMCApplication.h>
 109 #include <TGeoManager.h>
 110 #include <TObjString.h>
 111 #include <TSystem.h>
 112 #include <TFile.h>
 113
 114 #include "AliCodeTimer.h"
 115 #include "AliCDBStorage.h"
 116 #include "AliCDBEntry.h"
 117 #include "AliCDBManager.h"
 118 #include "AliGeomManager.h"
 119 #include "AliAlignObj.h"
 120 #include "AliCentralTrigger.h"
 121 #include "AliDAQ.h"
 122 #include "AliDigitizer.h"
 123 #include "AliGenerator.h"
 124 #include "AliLog.h"
 125 #include "AliModule.h"
 126 #include "AliRun.h"
 127 #include "AliRunDigitizer.h"
 128 #include "AliRunLoader.h"
 129 #include "AliSimulation.h"
 130 #include "AliVertexGenFile.h"
 131 #include "AliCentralTrigger.h"
 132 #include "AliCTPRawData.h"
 133 #include "AliRawReaderFile.h"
 134 #include "AliRawReaderRoot.h"
 135 #include "AliRawReaderDate.h"
 136 #include "AliESD.h"
 137 #include "AliHeader.h"
 138 #include "AliGenEventHeader.h"
 139 #include "AliMC.h"
 140 #include "AliHLTSimulation.h"
 141 #include "AliQADataMakerSteer.h"
 142 #include "AliSysInfo.h"
 143
 144 ClassImp(AliSimulation)
 145
 146 AliSimulation *AliSimulation::fgInstance = 0;
 147 const char* AliSimulation::fgkDetectorName[AliSimulation::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT"};
 148
 149 //_____________________________________________________________________________
 150 AliSimulation::AliSimulation(const char* configFileName,
 151                              const char* name, const char* title) :
 152   TNamed(name, title),
 153
 154   fRunGeneration(kTRUE),
 155   fRunSimulation(kTRUE),
 156   fLoadAlignFromCDB(kTRUE),
 157   fLoadAlObjsListOfDets("ALL"),
 158   fMakeSDigits("ALL"),
 159   fMakeDigits("ALL"),
 160   fMakeTrigger(""),
 161   fMakeDigitsFromHits(""),
 162   fWriteRawData(""),
 163   fRawDataFileName(""),
 164   fDeleteIntermediateFiles(kFALSE),
 165   fWriteSelRawData(kFALSE),
 166   fStopOnError(kFALSE),
 167
 168   fNEvents(1),
 169   fConfigFileName(configFileName),
 170   fGAliceFileName("galice.root"),
 171   fEventsPerFile(),
 172   fBkgrdFileNames(NULL),
 173   fAlignObjArray(NULL),
 174   fUseBkgrdVertex(kTRUE),
 175   fRegionOfInterest(kFALSE),
 176   fCDBUri(""),
 177   fSpecCDBUri(),
 178   fRun(-1),
 179   fSeed(0),
 180   fInitCDBCalled(kFALSE),
 181   fInitRunNumberCalled(kFALSE),
 182   fSetRunNumberFromDataCalled(kFALSE),
 183   fEmbeddingFlag(kFALSE),
 184   fRunQA(kTRUE),
 185   fRunHLT("default")
 186 {
 187 // create simulation object with default parameters
 188   fgInstance = this;
 189   SetGAliceFile("galice.root");
 190
 191 // for QA
 192    for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++)
 193         fQACycles[iDet] = 999999;
 194 }
 195
 196 //_____________________________________________________________________________
 197 AliSimulation::AliSimulation(const AliSimulation& sim) :
 198   TNamed(sim),
 199
 200   fRunGeneration(sim.fRunGeneration),
 201   fRunSimulation(sim.fRunSimulation),
 202   fLoadAlignFromCDB(sim.fLoadAlignFromCDB),
 203   fLoadAlObjsListOfDets(sim.fLoadAlObjsListOfDets),
 204   fMakeSDigits(sim.fMakeSDigits),
 205   fMakeDigits(sim.fMakeDigits),
 206   fMakeTrigger(sim.fMakeTrigger),
 207   fMakeDigitsFromHits(sim.fMakeDigitsFromHits),
 208   fWriteRawData(sim.fWriteRawData),
 209   fRawDataFileName(""),
 210   fDeleteIntermediateFiles(kFALSE),
 211   fWriteSelRawData(kFALSE),
 212   fStopOnError(sim.fStopOnError),
 213
 214   fNEvents(sim.fNEvents),
 215   fConfigFileName(sim.fConfigFileName),
 216   fGAliceFileName(sim.fGAliceFileName),
 217   fEventsPerFile(),
 218   fBkgrdFileNames(NULL),
 219   fAlignObjArray(NULL),
 220   fUseBkgrdVertex(sim.fUseBkgrdVertex),
 221   fRegionOfInterest(sim.fRegionOfInterest),
 222   fCDBUri(sim.fCDBUri),
 223   fSpecCDBUri(),
 224   fRun(-1),
 225   fSeed(0),
 226   fInitCDBCalled(sim.fInitCDBCalled),
 227   fInitRunNumberCalled(sim.fInitRunNumberCalled),
 228   fSetRunNumberFromDataCalled(sim.fSetRunNumberFromDataCalled),
 229   fEmbeddingFlag(sim.fEmbeddingFlag),
 230   fRunQA(kTRUE),
 231   fRunHLT(sim.fRunHLT)
 232 {
 233 // copy constructor
 234
 235   for (Int_t i = 0; i < sim.fEventsPerFile.GetEntriesFast(); i++) {
 236     if (!sim.fEventsPerFile[i]) continue;
 237     fEventsPerFile.Add(sim.fEventsPerFile[i]->Clone());
 238   }
 239
 240   fBkgrdFileNames = new TObjArray;
 241   for (Int_t i = 0; i < sim.fBkgrdFileNames->GetEntriesFast(); i++) {
 242     if (!sim.fBkgrdFileNames->At(i)) continue;
 243     fBkgrdFileNames->Add(sim.fBkgrdFileNames->At(i)->Clone());
 244   }
 245
 246   for (Int_t i = 0; i < sim.fSpecCDBUri.GetEntriesFast(); i++) {
 247     if (sim.fSpecCDBUri[i]) fSpecCDBUri.Add(sim.fSpecCDBUri[i]->Clone());
 248   }
 249   fgInstance = this;
 250
 251 // for QA
 252    for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++)
 253         fQACycles[iDet] = sim.fQACycles[iDet];
 254 }
 255
 256 //_____________________________________________________________________________
 257 AliSimulation& AliSimulation::operator = (const AliSimulation& sim)
 258 {
 259 // assignment operator
 260
 261   this->~AliSimulation();
 262   new(this) AliSimulation(sim);
 263   return *this;
 264 }
 265
 266 //_____________________________________________________________________________
 267 AliSimulation::~AliSimulation()
 268 {
 269 // clean up
 270
 271   fEventsPerFile.Delete();
 272 //  if(fAlignObjArray) fAlignObjArray->Delete(); // fAlignObjArray->RemoveAll() ???
 273 //  delete fAlignObjArray; fAlignObjArray=0;
 274
 275   if (fBkgrdFileNames) {
 276     fBkgrdFileNames->Delete();
 277     delete fBkgrdFileNames;
 278   }
 279
 280   fSpecCDBUri.Delete();
 281   if (fgInstance==this) fgInstance = 0;
 282
 283   AliCodeTimer::Instance()->Print();
 284 }
 285
 286
 287 //_____________________________________________________________________________
 288 void AliSimulation::SetNumberOfEvents(Int_t nEvents)
 289 {
 290 // set the number of events for one run
 291
 292   fNEvents = nEvents;
 293 }
 294
 295 //_____________________________________________________________________________
 296 void AliSimulation::InitCDB()
 297 {
 298 // activate a default CDB storage
 299 // First check if we have any CDB storage set, because it is used
 300 // to retrieve the calibration and alignment constants
 301
 302   if (fInitCDBCalled) return;
 303   fInitCDBCalled = kTRUE;
 304
 305   AliCDBManager* man = AliCDBManager::Instance();
 306   if (man->IsDefaultStorageSet())
 307   {
 308     AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 309     AliWarning("Default CDB storage has been already set !");
 310     AliWarning(Form("Ignoring the default storage declared in AliSimulation: %s",fCDBUri.Data()));
 311     AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 312     fCDBUri = man->GetDefaultStorage()->GetURI();
 313   }
 314   else {
 315     if (fCDBUri.Length() > 0)
 316     {
 317         AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 318         AliDebug(2, Form("Default CDB storage is set to: %s", fCDBUri.Data()));
 319         AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 320     } else {
 321         fCDBUri="local://$ALICE_ROOT";
 322         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 323         AliWarning("Default CDB storage not yet set !!!!");
 324         AliWarning(Form("Setting it now to: %s", fCDBUri.Data()));
 325         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 326
 327     }
 328     man->SetDefaultStorage(fCDBUri);
 329   }
 330
 331   // Now activate the detector specific CDB storage locations
 332   for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
 333     TObject* obj = fSpecCDBUri[i];
 334     if (!obj) continue;
 335     AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 336     AliDebug(2, Form("Specific CDB storage for %s is set to: %s",obj->GetName(),obj->GetTitle()));
 337     AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 338     man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
 339   }
 340
 341 }
 342
 343 //_____________________________________________________________________________
 344 void AliSimulation::InitRunNumber(){
 345 // check run number. If not set, set it to 0 !!!!
 346
 347   if (fInitRunNumberCalled) return;
 348   fInitRunNumberCalled = kTRUE;
 349
 350   AliCDBManager* man = AliCDBManager::Instance();
 351   if (man->GetRun() >= 0)
 352   {
 353         AliFatal(Form("Run number cannot be set in AliCDBManager before start of simulation: "
 354                         "Use external variable DC_RUN or AliSimulation::SetRun()!"));
 355   }
 356
 357   if(fRun >= 0) {
 358         AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 359         AliDebug(2, Form("Setting CDB run number to: %d",fRun));
 360         AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 361   } else {
 362         fRun=0;
 363         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 364         AliWarning("Run number not yet set !!!!");
 365         AliWarning(Form("Setting it now to: %d", fRun));
 366         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 367
 368   }
 369   man->SetRun(fRun);
 370
 371   man->Print();
 372
 373 }
 374
 375 //_____________________________________________________________________________
 376 void AliSimulation::SetCDBLock() {
 377   // Set CDB lock: from now on it is forbidden to reset the run number
 378   // or the default storage or to activate any further storage!
 379
 380   AliCDBManager::Instance()->SetLock(1);
 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::SetSpecificStorage(const char* calibType, const char* uri) {
 394 // Store a detector-specific CDB storage location
 395 // Activate it later within the Run() method
 396
 397   AliCDBPath aPath(calibType);
 398   if(!aPath.IsValid()){
 399         AliError(Form("Not a valid path: %s", calibType));
 400         return;
 401   }
 402
 403   TObject* obj = fSpecCDBUri.FindObject(calibType);
 404   if (obj) fSpecCDBUri.Remove(obj);
 405   fSpecCDBUri.Add(new TNamed(calibType, uri));
 406
 407 }
 408
 409 //_____________________________________________________________________________
 410 void AliSimulation::SetRunNumber(Int_t run)
 411 {
 412 // sets run number
 413 // Activate it later within the Run() method
 414
 415         fRun = run;
 416 }
 417
 418 //_____________________________________________________________________________
 419 void AliSimulation::SetSeed(Int_t seed)
 420 {
 421 // sets seed number
 422 // Activate it later within the Run() method
 423
 424         fSeed = seed;
 425 }
 426
 427 //_____________________________________________________________________________
 428 Bool_t AliSimulation::SetRunNumberFromData()
 429 {
 430   // Set the CDB manager run number
 431   // The run number is retrieved from gAlice
 432
 433     if (fSetRunNumberFromDataCalled) return kTRUE;
 434     fSetRunNumberFromDataCalled = kTRUE;
 435
 436     AliCDBManager* man = AliCDBManager::Instance();
 437     Int_t runData = -1, runCDB = -1;
 438
 439     AliRunLoader* runLoader = LoadRun("READ");
 440     if (!runLoader) return kFALSE;
 441     else {
 442         runData = runLoader->GetAliRun()->GetHeader()->GetRun();
 443         delete runLoader;
 444     }
 445
 446     runCDB = man->GetRun();
 447     if(runCDB >= 0) {
 448         if (runCDB != runData) {
 449                 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 450                 AliWarning(Form("A run number was previously set in AliCDBManager: %d !", runCDB));
 451                 AliWarning(Form("It will be replaced with the run number got from run header: %d !", runData));
 452                 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 453         }
 454
 455     }
 456
 457     man->SetRun(runData);
 458     fRun = runData;
 459
 460     if(man->GetRun() < 0) {
 461         AliError("Run number not properly initalized!");
 462         return kFALSE;
 463     }
 464
 465     man->Print();
 466
 467     return kTRUE;
 468 }
 469
 470 //_____________________________________________________________________________
 471 void AliSimulation::SetConfigFile(const char* fileName)
 472 {
 473 // set the name of the config file
 474
 475   fConfigFileName = fileName;
 476 }
 477
 478 //_____________________________________________________________________________
 479 void AliSimulation::SetGAliceFile(const char* fileName)
 480 {
 481 // set the name of the galice file
 482 // the path is converted to an absolute one if it is relative
 483
 484   fGAliceFileName = fileName;
 485   if (!gSystem->IsAbsoluteFileName(fGAliceFileName)) {
 486     char* absFileName = gSystem->ConcatFileName(gSystem->WorkingDirectory(),
 487                                                 fGAliceFileName);
 488     fGAliceFileName = absFileName;
 489     delete[] absFileName;
 490   }
 491
 492   AliDebug(2, Form("galice file name set to %s", fileName));
 493 }
 494
 495 //_____________________________________________________________________________
 496 void AliSimulation::SetEventsPerFile(const char* detector, const char* type,
 497                                      Int_t nEvents)
 498 {
 499 // set the number of events per file for the given detector and data type
 500 // ("Hits", "Summable Digits", "Digits", "Reconstructed Points" or "Tracks")
 501
 502   TNamed* obj = new TNamed(detector, type);
 503   obj->SetUniqueID(nEvents);
 504   fEventsPerFile.Add(obj);
 505 }
 506
 507 //_____________________________________________________________________________
 508 Bool_t AliSimulation::MisalignGeometry(AliRunLoader *runLoader)
 509 {
 510   // Read the alignment objects from CDB.
 511   // Each detector is supposed to have the
 512   // alignment objects in DET/Align/Data CDB path.
 513   // All the detector objects are then collected,
 514   // sorted by geometry level (starting from ALIC) and
 515   // then applied to the TGeo geometry.
 516   // Finally an overlaps check is performed.
 517
 518   if (!AliGeomManager::GetGeometry() || !AliGeomManager::GetGeometry()->IsClosed()) {
 519     AliError("Can't apply the misalignment! Geometry is not loaded or it is still opened!");
 520     return kFALSE;
 521   }
 522
 523   // initialize CDB storage, run number, set CDB lock
 524   InitCDB();
 525 //  if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
 526   SetCDBLock();
 527
 528   Bool_t delRunLoader = kFALSE;
 529   if (!runLoader) {
 530     runLoader = LoadRun("READ");
 531     if (!runLoader) return kFALSE;
 532     delRunLoader = kTRUE;
 533   }
 534
 535   // Export ideal geometry
 536   if(!gAlice->IsRootGeometry()) AliGeomManager::GetGeometry()->Export("geometry.root");
 537
 538   // Load alignment data from CDB and apply to geometry through AliGeomManager
 539   if(fLoadAlignFromCDB){
 540
 541     TString detStr = fLoadAlObjsListOfDets;
 542     TString loadAlObjsListOfDets = "";
 543
 544     TObjArray* detArray = runLoader->GetAliRun()->Detectors();
 545     for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
 546       AliModule* det = (AliModule*) detArray->At(iDet);
 547       if (!det || !det->IsActive()) continue;
 548       if (IsSelected(det->GetName(), detStr)) {
 549         //add det to list of dets to be aligned from CDB
 550         loadAlObjsListOfDets += det->GetName();
 551         loadAlObjsListOfDets += " ";
 552       }
 553     } // end loop over detectors
 554     loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
 555     AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
 556   }else{
 557     // Check if the array with alignment objects was
 558     // provided by the user. If yes, apply the objects
 559     // to the present TGeo geometry
 560     if (fAlignObjArray) {
 561       if (AliGeomManager::ApplyAlignObjsToGeom(*fAlignObjArray) == kFALSE) {
 562         AliError("The misalignment of one or more volumes failed!"
 563                  "Compare the list of simulated detectors and the list of detector alignment data!");
 564         if (delRunLoader) delete runLoader;
 565         return kFALSE;
 566       }
 567     }
 568   }
 569
 570   // Update the internal geometry of modules (ITS needs it)
 571   TString detStr = fLoadAlObjsListOfDets;
 572   TObjArray* detArray = runLoader->GetAliRun()->Detectors();
 573   for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
 574
 575     AliModule* det = (AliModule*) detArray->At(iDet);
 576     if (!det || !det->IsActive()) continue;
 577     if (IsSelected(det->GetName(), detStr)) {
 578       det->UpdateInternalGeometry();
 579     }
 580   } // end loop over detectors
 581
 582
 583   if (delRunLoader) delete runLoader;
 584
 585   return kTRUE;
 586 }
 587
 588 //_____________________________________________________________________________
 589 void AliSimulation::MergeWith(const char* fileName, Int_t nSignalPerBkgrd)
 590 {
 591 // add a file with background events for merging
 592
 593   TObjString* fileNameStr = new TObjString(fileName);
 594   fileNameStr->SetUniqueID(nSignalPerBkgrd);
 595   if (!fBkgrdFileNames) fBkgrdFileNames = new TObjArray;
 596   fBkgrdFileNames->Add(fileNameStr);
 597 }
 598
 599 void AliSimulation::EmbedInto(const char* fileName, Int_t nSignalPerBkgrd)
 600 {
 601 // add a file with background events for embeddin
 602   MergeWith(fileName, nSignalPerBkgrd);
 603   fEmbeddingFlag = kTRUE;
 604 }
 605
 606 //_____________________________________________________________________________
 607 Bool_t AliSimulation::Run(Int_t nEvents)
 608 {
 609 // run the generation, simulation and digitization
 610
 611
 612   AliCodeTimerAuto("")
 613
 614   // Load run number and seed from environmental vars
 615   ProcessEnvironmentVars();
 616
 617   gRandom->SetSeed(fSeed);
 618
 619   if (nEvents > 0) fNEvents = nEvents;
 620
 621   // generation and simulation -> hits
 622   if (fRunGeneration) {
 623     if (!RunSimulation()) if (fStopOnError) return kFALSE;
 624   }
 625
 626   // initialize CDB storage from external environment
 627   // (either CDB manager or AliSimulation setters),
 628   // if not already done in RunSimulation()
 629   InitCDB();
 630
 631   // Set run number in CDBManager from data
 632   // From this point on the run number must be always loaded from data!
 633   if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
 634
 635   // Set CDB lock: from now on it is forbidden to reset the run number
 636   // or the default storage or to activate any further storage!
 637   SetCDBLock();
 638
 639   // If RunSimulation was not called, load the geometry and misalign it
 640   if (!AliGeomManager::GetGeometry()) {
 641     // Initialize the geometry manager
 642     AliGeomManager::LoadGeometry("geometry.root");
 643     if (!AliGeomManager::GetGeometry()) if (fStopOnError) return kFALSE;
 644     // Misalign geometry
 645     if(!MisalignGeometry()) if (fStopOnError) return kFALSE;
 646   }
 647
 648
 649   // hits -> summable digits
 650   AliSysInfo::AddStamp("Start_sdigitization");
 651   if (!fMakeSDigits.IsNull()) {
 652     if (!RunSDigitization(fMakeSDigits)) if (fStopOnError) return kFALSE;
 653
 654   }
 655   AliSysInfo::AddStamp("Stop_sdigitization");
 656
 657   AliSysInfo::AddStamp("Start_digitization");
 658   // summable digits -> digits
 659   if (!fMakeDigits.IsNull()) {
 660     if (!RunDigitization(fMakeDigits, fMakeDigitsFromHits)) {
 661       if (fStopOnError) return kFALSE;
 662     }
 663    }
 664   AliSysInfo::AddStamp("Stop_digitization");
 665
 666
 667
 668   // hits -> digits
 669   if (!fMakeDigitsFromHits.IsNull()) {
 670     if (fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
 671       AliWarning(Form("Merging and direct creation of digits from hits "
 672                  "was selected for some detectors. "
 673                  "No merging will be done for the following detectors: %s",
 674                  fMakeDigitsFromHits.Data()));
 675     }
 676     if (!RunHitsDigitization(fMakeDigitsFromHits)) {
 677       if (fStopOnError) return kFALSE;
 678     }
 679   }
 680
 681
 682
 683   // digits -> trigger
 684   if (!RunTrigger(fMakeTrigger,fMakeDigits)) {
 685     if (fStopOnError) return kFALSE;
 686   }
 687
 688
 689
 690   // digits -> raw data
 691   if (!fWriteRawData.IsNull()) {
 692     if (!WriteRawData(fWriteRawData, fRawDataFileName,
 693                       fDeleteIntermediateFiles,fWriteSelRawData)) {
 694       if (fStopOnError) return kFALSE;
 695     }
 696   }
 697
 698
 699
 700   // run HLT simulation
 701   if (!fRunHLT.IsNull()) {
 702     if (!RunHLT()) {
 703       if (fStopOnError) return kFALSE;
 704     }
 705   }
 706
 707   //QA
 708         if (fRunQA) {
 709                 Bool_t rv = RunQA() ;
 710                 if (!rv)
 711                         if (fStopOnError)
 712                                 return kFALSE ;
 713         }
 714
 715   // Cleanup of CDB manager: cache and active storages!
 716   AliCDBManager::Instance()->ClearCache();
 717
 718   return kTRUE;
 719 }
 720
 721 //_____________________________________________________________________________
 722 Bool_t AliSimulation::RunTrigger(const char* config, const char* detectors)
 723 {
 724   // run the trigger
 725
 726   AliCodeTimerAuto("")
 727
 728   // initialize CDB storage from external environment
 729   // (either CDB manager or AliSimulation setters),
 730   // if not already done in RunSimulation()
 731   InitCDB();
 732
 733   // Set run number in CDBManager from data
 734   // From this point on the run number must be always loaded from data!
 735   if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
 736
 737   // Set CDB lock: from now on it is forbidden to reset the run number
 738   // or the default storage or to activate any further storage!
 739   SetCDBLock();
 740
 741    AliRunLoader* runLoader = LoadRun("READ");
 742    if (!runLoader) return kFALSE;
 743    TString trconfiguration = config;
 744
 745    if (trconfiguration.IsNull()) {
 746      if (gAlice->GetTriggerDescriptor() != "") {
 747        trconfiguration = gAlice->GetTriggerDescriptor();
 748      }
 749      else
 750        AliWarning("No trigger descriptor is specified. Loading the one that is in the CDB.");
 751    }
 752
 753    runLoader->MakeTree( "GG" );
 754    AliCentralTrigger* aCTP = runLoader->GetTrigger();
 755    // Load Configuration
 756    if (!aCTP->LoadConfiguration( trconfiguration ))
 757      return kFALSE;
 758
 759    // digits -> trigger
 760    if( !aCTP->RunTrigger( runLoader , detectors ) ) {
 761       if (fStopOnError) {
 762         //  delete aCTP;
 763         return kFALSE;
 764       }
 765    }
 766
 767    delete runLoader;
 768
 769    return kTRUE;
 770 }
 771
 772 //_____________________________________________________________________________
 773 Bool_t AliSimulation::WriteTriggerRawData()
 774 {
 775   // Writes the CTP (trigger) DDL raw data
 776   // Details of the format are given in the
 777   // trigger TDR - pages 134 and 135.
 778   AliCTPRawData writer;
 779   writer.RawData();
 780
 781   return kTRUE;
 782 }
 783
 784 //_____________________________________________________________________________
 785 Bool_t AliSimulation::RunSimulation(Int_t nEvents)
 786 {
 787 // run the generation and simulation
 788
 789   AliCodeTimerAuto("")
 790
 791   // initialize CDB storage and run number from external environment
 792   // (either CDB manager or AliSimulation setters)
 793   InitCDB();
 794   InitRunNumber();
 795   SetCDBLock();
 796
 797   if (!gAlice) {
 798     AliError("no gAlice object. Restart aliroot and try again.");
 799     return kFALSE;
 800   }
 801   if (gAlice->Modules()->GetEntries() > 0) {
 802     AliError("gAlice was already run. Restart aliroot and try again.");
 803     return kFALSE;
 804   }
 805
 806   AliInfo(Form("initializing gAlice with config file %s",
 807           fConfigFileName.Data()));
 808   StdoutToAliInfo(StderrToAliError(
 809     gAlice->Init(fConfigFileName.Data());
 810   ););
 811
 812   // Get the trigger descriptor string
 813   // Either from AliSimulation or from
 814   // gAlice
 815   if (fMakeTrigger.IsNull()) {
 816     if (gAlice->GetTriggerDescriptor() != "")
 817       fMakeTrigger = gAlice->GetTriggerDescriptor();
 818   }
 819   else
 820     gAlice->SetTriggerDescriptor(fMakeTrigger.Data());
 821
 822   // Set run number in CDBManager
 823   AliInfo(Form("Run number: %d",AliCDBManager::Instance()->GetRun()));
 824
 825   AliRunLoader* runLoader = gAlice->GetRunLoader();
 826   if (!runLoader) {
 827              AliError(Form("gAlice has no run loader object. "
 828                              "Check your config file: %s", fConfigFileName.Data()));
 829              return kFALSE;
 830   }
 831   SetGAliceFile(runLoader->GetFileName());
 832
 833   // Misalign geometry
 834 #if ROOT_VERSION_CODE < 331527
 835   AliGeomManager::SetGeometry(gGeoManager);
 836   MisalignGeometry(runLoader);
 837 #endif
 838
 839 //   AliRunLoader* runLoader = gAlice->GetRunLoader();
 840 //   if (!runLoader) {
 841 //     AliError(Form("gAlice has no run loader object. "
 842 //                   "Check your config file: %s", fConfigFileName.Data()));
 843 //     return kFALSE;
 844 //   }
 845 //   SetGAliceFile(runLoader->GetFileName());
 846
 847   if (!gAlice->Generator()) {
 848     AliError(Form("gAlice has no generator object. "
 849                   "Check your config file: %s", fConfigFileName.Data()));
 850     return kFALSE;
 851   }
 852   if (nEvents <= 0) nEvents = fNEvents;
 853
 854   // get vertex from background file in case of merging
 855   if (fUseBkgrdVertex &&
 856       fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
 857     Int_t signalPerBkgrd = GetNSignalPerBkgrd(nEvents);
 858     const char* fileName = ((TObjString*)
 859                             (fBkgrdFileNames->At(0)))->GetName();
 860     AliInfo(Form("The vertex will be taken from the background "
 861                  "file %s with nSignalPerBackground = %d",
 862                  fileName, signalPerBkgrd));
 863     AliVertexGenFile* vtxGen = new AliVertexGenFile(fileName, signalPerBkgrd);
 864     gAlice->Generator()->SetVertexGenerator(vtxGen);
 865   }
 866
 867   if (!fRunSimulation) {
 868     gAlice->Generator()->SetTrackingFlag(0);
 869   }
 870
 871   // set the number of events per file for given detectors and data types
 872   for (Int_t i = 0; i < fEventsPerFile.GetEntriesFast(); i++) {
 873     if (!fEventsPerFile[i]) continue;
 874     const char* detName = fEventsPerFile[i]->GetName();
 875     const char* typeName = fEventsPerFile[i]->GetTitle();
 876     TString loaderName(detName);
 877     loaderName += "Loader";
 878     AliLoader* loader = runLoader->GetLoader(loaderName);
 879     if (!loader) {
 880       AliError(Form("RunSimulation", "no loader for %s found\n"
 881                     "Number of events per file not set for %s %s",
 882                     detName, typeName, detName));
 883       continue;
 884     }
 885     AliDataLoader* dataLoader =
 886       loader->GetDataLoader(typeName);
 887     if (!dataLoader) {
 888       AliError(Form("no data loader for %s found\n"
 889                     "Number of events per file not set for %s %s",
 890                     typeName, detName, typeName));
 891       continue;
 892     }
 893     dataLoader->SetNumberOfEventsPerFile(fEventsPerFile[i]->GetUniqueID());
 894     AliDebug(1, Form("number of events per file set to %d for %s %s",
 895                      fEventsPerFile[i]->GetUniqueID(), detName, typeName));
 896   }
 897
 898   AliInfo("running gAlice");
 899   AliSysInfo::AddStamp("Start_simulation");
 900   StdoutToAliInfo(StderrToAliError(
 901     gAlice->Run(nEvents);
 902   ););
 903   AliSysInfo::AddStamp("Stop_simulation");
 904   delete runLoader;
 905
 906   return kTRUE;
 907 }
 908
 909 //_____________________________________________________________________________
 910 Bool_t AliSimulation::RunSDigitization(const char* detectors)
 911 {
 912 // run the digitization and produce summable digits
 913   static Int_t eventNr=0;
 914   AliCodeTimerAuto("")
 915
 916   // initialize CDB storage, run number, set CDB lock
 917   InitCDB();
 918   if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
 919   SetCDBLock();
 920
 921   AliRunLoader* runLoader = LoadRun();
 922   if (!runLoader) return kFALSE;
 923
 924   TString detStr = detectors;
 925   TObjArray* detArray = runLoader->GetAliRun()->Detectors();
 926   for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
 927     AliModule* det = (AliModule*) detArray->At(iDet);
 928     if (!det || !det->IsActive()) continue;
 929     if (IsSelected(det->GetName(), detStr)) {
 930       AliInfo(Form("creating summable digits for %s", det->GetName()));
 931       AliCodeTimerAuto(Form("creating summable digits for %s", det->GetName()));
 932       det->Hits2SDigits();
 933       AliSysInfo::AddStamp(Form("Digit_%s_%d",det->GetName(),eventNr), 0,1, eventNr);
 934     }
 935   }
 936
 937   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
 938     AliError(Form("the following detectors were not found: %s",
 939                   detStr.Data()));
 940     if (fStopOnError) return kFALSE;
 941   }
 942   eventNr++;
 943   delete runLoader;
 944
 945   return kTRUE;
 946 }
 947
 948
 949 //_____________________________________________________________________________
 950 Bool_t AliSimulation::RunDigitization(const char* detectors,
 951                                       const char* excludeDetectors)
 952 {
 953 // run the digitization and produce digits from sdigits
 954
 955   AliCodeTimerAuto("")
 956
 957   // initialize CDB storage, run number, set CDB lock
 958   InitCDB();
 959   if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
 960   SetCDBLock();
 961
 962   while (AliRunLoader::GetRunLoader()) delete AliRunLoader::GetRunLoader();
 963   if (gAlice) delete gAlice;
 964   gAlice = NULL;
 965
 966   Int_t nStreams = 1;
 967   if (fBkgrdFileNames) nStreams = fBkgrdFileNames->GetEntriesFast() + 1;
 968   Int_t signalPerBkgrd = GetNSignalPerBkgrd();
 969   AliRunDigitizer* manager = new AliRunDigitizer(nStreams, signalPerBkgrd);
 970   // manager->SetEmbeddingFlag(fEmbeddingFlag);
 971   manager->SetInputStream(0, fGAliceFileName.Data());
 972   for (Int_t iStream = 1; iStream < nStreams; iStream++) {
 973     const char* fileName = ((TObjString*)
 974                             (fBkgrdFileNames->At(iStream-1)))->GetName();
 975     manager->SetInputStream(iStream, fileName);
 976   }
 977
 978   TString detStr = detectors;
 979   TString detExcl = excludeDetectors;
 980   manager->GetInputStream(0)->ImportgAlice();
 981   AliRunLoader* runLoader =
 982     AliRunLoader::GetRunLoader(manager->GetInputStream(0)->GetFolderName());
 983   TObjArray* detArray = runLoader->GetAliRun()->Detectors();
 984   for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
 985     AliModule* det = (AliModule*) detArray->At(iDet);
 986     if (!det || !det->IsActive()) continue;
 987     if (IsSelected(det->GetName(), detStr) &&
 988         !IsSelected(det->GetName(), detExcl)) {
 989       AliDigitizer* digitizer = det->CreateDigitizer(manager);
 990
 991       if (!digitizer) {
 992         AliError(Form("no digitizer for %s", det->GetName()));
 993         if (fStopOnError) return kFALSE;
 994       } else {
 995         digitizer->SetRegionOfInterest(fRegionOfInterest);
 996       }
 997     }
 998   }
 999
1000   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1001     AliError(Form("the following detectors were not found: %s",
1002                   detStr.Data()));
1003     if (fStopOnError) return kFALSE;
1004   }
1005
1006   if (!manager->GetListOfTasks()->IsEmpty()) {
1007     AliInfo("executing digitization");
1008     manager->Exec("");
1009   }
1010
1011   delete manager;
1012
1013   return kTRUE;
1014 }
1015
1016 //_____________________________________________________________________________
1017 Bool_t AliSimulation::RunHitsDigitization(const char* detectors)
1018 {
1019 // run the digitization and produce digits from hits
1020
1021   AliCodeTimerAuto("")
1022
1023   // initialize CDB storage, run number, set CDB lock
1024   InitCDB();
1025   if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
1026   SetCDBLock();
1027
1028   AliRunLoader* runLoader = LoadRun("READ");
1029   if (!runLoader) return kFALSE;
1030
1031   TString detStr = detectors;
1032   TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1033   for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1034     AliModule* det = (AliModule*) detArray->At(iDet);
1035     if (!det || !det->IsActive()) continue;
1036     if (IsSelected(det->GetName(), detStr)) {
1037       AliInfo(Form("creating digits from hits for %s", det->GetName()));
1038       det->Hits2Digits();
1039     }
1040   }
1041
1042   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1043     AliError(Form("the following detectors were not found: %s",
1044                   detStr.Data()));
1045     if (fStopOnError) return kFALSE;
1046   }
1047
1048   delete runLoader;
1049   //PH Temporary fix to avoid interference with the PHOS loder/getter
1050   //PH The problem has to be solved in more general way 09/06/05
1051
1052   return kTRUE;
1053 }
1054
1055 //_____________________________________________________________________________
1056 Bool_t AliSimulation::WriteRawData(const char* detectors,
1057                                    const char* fileName,
1058                                    Bool_t deleteIntermediateFiles,
1059                                    Bool_t selrawdata)
1060 {
1061 // convert the digits to raw data
1062 // First DDL raw data files for the given detectors are created.
1063 // If a file name is given, the DDL files are then converted to a DATE file.
1064 // If deleteIntermediateFiles is true, the DDL raw files are deleted
1065 // afterwards.
1066 // If the file name has the extension ".root", the DATE file is converted
1067 // to a root file.
1068 // If deleteIntermediateFiles is true, the DATE file is deleted afterwards.
1069 // 'selrawdata' flag can be used to enable writing of detectors raw data
1070 // accoring to the trigger cluster.
1071
1072   AliCodeTimerAuto("")
1073
1074   if (!WriteRawFiles(detectors)) {
1075     if (fStopOnError) return kFALSE;
1076   }
1077
1078   TString dateFileName(fileName);
1079   if (!dateFileName.IsNull()) {
1080     Bool_t rootOutput = dateFileName.EndsWith(".root");
1081     if (rootOutput) dateFileName += ".date";
1082     TString selDateFileName;
1083     if (selrawdata) {
1084       selDateFileName = "selected.";
1085       selDateFileName+= dateFileName;
1086     }
1087     if (!ConvertRawFilesToDate(dateFileName,selDateFileName)) {
1088       if (fStopOnError) return kFALSE;
1089     }
1090     if (deleteIntermediateFiles) {
1091       AliRunLoader* runLoader = LoadRun("READ");
1092       if (runLoader) for (Int_t iEvent = 0;
1093                           iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
1094         char command[256];
1095         sprintf(command, "rm -r raw%d", iEvent);
1096         gSystem->Exec(command);
1097       }
1098     }
1099
1100     if (rootOutput) {
1101       if (!ConvertDateToRoot(dateFileName, fileName)) {
1102         if (fStopOnError) return kFALSE;
1103       }
1104       if (deleteIntermediateFiles) {
1105         gSystem->Unlink(dateFileName);
1106       }
1107       if (selrawdata) {
1108         TString selFileName = "selected.";
1109         selFileName        += fileName;
1110         if (!ConvertDateToRoot(selDateFileName, selFileName)) {
1111           if (fStopOnError) return kFALSE;
1112         }
1113         if (deleteIntermediateFiles) {
1114           gSystem->Unlink(selDateFileName);
1115         }
1116       }
1117     }
1118   }
1119
1120   return kTRUE;
1121 }
1122
1123 //_____________________________________________________________________________
1124 Bool_t AliSimulation::WriteRawFiles(const char* detectors)
1125 {
1126 // convert the digits to raw data DDL files
1127
1128   AliCodeTimerAuto("")
1129
1130   AliRunLoader* runLoader = LoadRun("READ");
1131   if (!runLoader) return kFALSE;
1132
1133   // write raw data to DDL files
1134   for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
1135     AliInfo(Form("processing event %d", iEvent));
1136     runLoader->GetEvent(iEvent);
1137     TString baseDir = gSystem->WorkingDirectory();
1138     char dirName[256];
1139     sprintf(dirName, "raw%d", iEvent);
1140     gSystem->MakeDirectory(dirName);
1141     if (!gSystem->ChangeDirectory(dirName)) {
1142       AliError(Form("couldn't change to directory %s", dirName));
1143       if (fStopOnError) return kFALSE; else continue;
1144     }
1145
1146     TString detStr = detectors;
1147     TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1148     for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1149       AliModule* det = (AliModule*) detArray->At(iDet);
1150       if (!det || !det->IsActive()) continue;
1151       if (IsSelected(det->GetName(), detStr)) {
1152         AliInfo(Form("creating raw data from digits for %s", det->GetName()));
1153         det->Digits2Raw();
1154       }
1155     }
1156
1157     if (!WriteTriggerRawData())
1158       if (fStopOnError) return kFALSE;
1159
1160     gSystem->ChangeDirectory(baseDir);
1161     if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1162       AliError(Form("the following detectors were not found: %s",
1163                     detStr.Data()));
1164       if (fStopOnError) return kFALSE;
1165     }
1166   }
1167
1168   delete runLoader;
1169
1170   return kTRUE;
1171 }
1172
1173 //_____________________________________________________________________________
1174 Bool_t AliSimulation::ConvertRawFilesToDate(const char* dateFileName,
1175                                             const char* selDateFileName)
1176 {
1177 // convert raw data DDL files to a DATE file with the program "dateStream"
1178 // The second argument is not empty when the user decides to write
1179 // the detectors raw data according to the trigger cluster.
1180
1181   AliCodeTimerAuto("")
1182
1183   char* path = gSystem->Which(gSystem->Getenv("PATH"), "dateStream");
1184   if (!path) {
1185     AliError("the program dateStream was not found");
1186     if (fStopOnError) return kFALSE;
1187   } else {
1188     delete[] path;
1189   }
1190
1191   AliRunLoader* runLoader = LoadRun("READ");
1192   if (!runLoader) return kFALSE;
1193
1194   AliInfo(Form("converting raw data DDL files to DATE file %s", dateFileName));
1195   Bool_t selrawdata = kFALSE;
1196   if (strcmp(selDateFileName,"") != 0) selrawdata = kTRUE;
1197
1198   char command[256];
1199   // Note the option -s. It is used in order to avoid
1200   // the generation of SOR/EOR events.
1201   sprintf(command, "dateStream -c -s -D -o %s -# %d -C -run %d",
1202           dateFileName, runLoader->GetNumberOfEvents(),runLoader->GetHeader()->GetRun());
1203   FILE* pipe = gSystem->OpenPipe(command, "w");
1204
1205   Int_t selEvents = 0;
1206   for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
1207     fprintf(pipe, "GDC\n");
1208     Float_t ldc = 0;
1209     Int_t prevLDC = -1;
1210
1211     if (selrawdata) {
1212       // Check if the event was triggered by CTP
1213       runLoader->GetEvent(iEvent);
1214       if (!runLoader->LoadTrigger()) {
1215         AliCentralTrigger *aCTP = runLoader->GetTrigger();
1216         if (aCTP->GetClassMask()) selEvents++;
1217       }
1218       else {
1219         AliWarning("No trigger can be loaded! Writing of selected raw data is abandoned !");
1220         selrawdata = kFALSE;
1221       }
1222     }
1223
1224     // loop over detectors and DDLs
1225     for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
1226       for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls(iDet); iDDL++) {
1227
1228         Int_t ddlID = AliDAQ::DdlID(iDet,iDDL);
1229         Int_t ldcID = Int_t(ldc + 0.0001);
1230         ldc += AliDAQ::NumberOfLdcs(iDet) / AliDAQ::NumberOfDdls(iDet);
1231
1232         char rawFileName[256];
1233         sprintf(rawFileName, "raw%d/%s",
1234                 iEvent, AliDAQ::DdlFileName(iDet,iDDL));
1235
1236         // check existence and size of raw data file
1237         FILE* file = fopen(rawFileName, "rb");
1238         if (!file) continue;
1239         fseek(file, 0, SEEK_END);
1240         unsigned long size = ftell(file);
1241         fclose(file);
1242         if (!size) continue;
1243
1244         if (ldcID != prevLDC) {
1245           fprintf(pipe, " LDC Id %d\n", ldcID);
1246           prevLDC = ldcID;
1247         }
1248         fprintf(pipe, "  Equipment Id %d Payload %s\n", ddlID, rawFileName);
1249       }
1250     }
1251   }
1252
1253   Int_t result = gSystem->ClosePipe(pipe);
1254
1255   if (!(selrawdata && selEvents > 0)) {
1256     delete runLoader;
1257     return (result == 0);
1258   }
1259
1260   AliInfo(Form("converting selected by trigger cluster raw data DDL files to DATE file %s", selDateFileName));
1261
1262   sprintf(command, "dateStream -c -s -D -o %s -# %d -C -run %d",
1263           selDateFileName,selEvents,runLoader->GetHeader()->GetRun());
1264   FILE* pipe2 = gSystem->OpenPipe(command, "w");
1265
1266   for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
1267
1268     // Get the trigger decision and cluster
1269     TString detClust;
1270     runLoader->GetEvent(iEvent);
1271     if (!runLoader->LoadTrigger()) {
1272       AliCentralTrigger *aCTP = runLoader->GetTrigger();
1273       if (aCTP->GetClassMask() == 0) continue;
1274       detClust = aCTP->GetTriggeredDetectors();
1275       AliInfo(Form("List of detectors to be read out: %s",detClust.Data()));
1276     }
1277
1278     fprintf(pipe2, "GDC\n");
1279     Float_t ldc = 0;
1280     Int_t prevLDC = -1;
1281
1282     // loop over detectors and DDLs
1283     for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
1284       // Write only raw data from detectors that
1285       // are contained in the trigger cluster(s)
1286       if (!IsSelected(AliDAQ::DetectorName(iDet),detClust)) continue;
1287
1288       for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls(iDet); iDDL++) {
1289
1290         Int_t ddlID = AliDAQ::DdlID(iDet,iDDL);
1291         Int_t ldcID = Int_t(ldc + 0.0001);
1292         ldc += AliDAQ::NumberOfLdcs(iDet) / AliDAQ::NumberOfDdls(iDet);
1293
1294         char rawFileName[256];
1295         sprintf(rawFileName, "raw%d/%s",
1296                 iEvent, AliDAQ::DdlFileName(iDet,iDDL));
1297
1298         // check existence and size of raw data file
1299         FILE* file = fopen(rawFileName, "rb");
1300         if (!file) continue;
1301         fseek(file, 0, SEEK_END);
1302         unsigned long size = ftell(file);
1303         fclose(file);
1304         if (!size) continue;
1305
1306         if (ldcID != prevLDC) {
1307           fprintf(pipe2, " LDC Id %d\n", ldcID);
1308           prevLDC = ldcID;
1309         }
1310         fprintf(pipe2, "  Equipment Id %d Payload %s\n", ddlID, rawFileName);
1311       }
1312     }
1313   }
1314
1315   Int_t result2 = gSystem->ClosePipe(pipe2);
1316
1317   delete runLoader;
1318   return ((result == 0) && (result2 == 0));
1319 }
1320
1321 //_____________________________________________________________________________
1322 Bool_t AliSimulation::ConvertDateToRoot(const char* dateFileName,
1323                                         const char* rootFileName)
1324 {
1325 // convert a DATE file to a root file with the program "alimdc"
1326
1327   // ALIMDC setup
1328   const Int_t kDBSize = 2000000000;
1329   const Int_t kTagDBSize = 1000000000;
1330   const Bool_t kFilter = kFALSE;
1331   const Int_t kCompression = 1;
1332
1333   char* path = gSystem->Which(gSystem->Getenv("PATH"), "alimdc");
1334   if (!path) {
1335     AliError("the program alimdc was not found");
1336     if (fStopOnError) return kFALSE;
1337   } else {
1338     delete[] path;
1339   }
1340
1341   AliInfo(Form("converting DATE file %s to root file %s",
1342                dateFileName, rootFileName));
1343
1344   const char* rawDBFS[2] = { "/tmp/mdc1", "/tmp/mdc2" };
1345   const char* tagDBFS    = "/tmp/mdc1/tags";
1346
1347   // User defined file system locations
1348   if (gSystem->Getenv("ALIMDC_RAWDB1"))
1349     rawDBFS[0] = gSystem->Getenv("ALIMDC_RAWDB1");
1350   if (gSystem->Getenv("ALIMDC_RAWDB2"))
1351     rawDBFS[1] = gSystem->Getenv("ALIMDC_RAWDB2");
1352   if (gSystem->Getenv("ALIMDC_TAGDB"))
1353     tagDBFS = gSystem->Getenv("ALIMDC_TAGDB");
1354
1355   gSystem->Exec(Form("rm -rf %s",rawDBFS[0]));
1356   gSystem->Exec(Form("rm -rf %s",rawDBFS[1]));
1357   gSystem->Exec(Form("rm -rf %s",tagDBFS));
1358
1359   gSystem->Exec(Form("mkdir %s",rawDBFS[0]));
1360   gSystem->Exec(Form("mkdir %s",rawDBFS[1]));
1361   gSystem->Exec(Form("mkdir %s",tagDBFS));
1362
1363   Int_t result = gSystem->Exec(Form("alimdc %d %d %d %d %s",
1364                                     kDBSize, kTagDBSize, kFilter, kCompression, dateFileName));
1365   gSystem->Exec(Form("mv %s/*.root %s", rawDBFS[0], rootFileName));
1366
1367   gSystem->Exec(Form("rm -rf %s",rawDBFS[0]));
1368   gSystem->Exec(Form("rm -rf %s",rawDBFS[1]));
1369   gSystem->Exec(Form("rm -rf %s",tagDBFS));
1370
1371   return (result == 0);
1372 }
1373
1374
1375 //_____________________________________________________________________________
1376 AliRunLoader* AliSimulation::LoadRun(const char* mode) const
1377 {
1378 // delete existing run loaders, open a new one and load gAlice
1379
1380   while (AliRunLoader::GetRunLoader()) delete AliRunLoader::GetRunLoader();
1381   AliRunLoader* runLoader =
1382     AliRunLoader::Open(fGAliceFileName.Data(),
1383                        AliConfig::GetDefaultEventFolderName(), mode);
1384   if (!runLoader) {
1385     AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
1386     return NULL;
1387   }
1388   runLoader->LoadgAlice();
1389   runLoader->LoadHeader();
1390   gAlice = runLoader->GetAliRun();
1391   if (!gAlice) {
1392     AliError(Form("no gAlice object found in file %s",
1393                   fGAliceFileName.Data()));
1394     return NULL;
1395   }
1396   return runLoader;
1397 }
1398
1399 //_____________________________________________________________________________
1400 Int_t AliSimulation::GetNSignalPerBkgrd(Int_t nEvents) const
1401 {
1402 // get or calculate the number of signal events per background event
1403
1404   if (!fBkgrdFileNames) return 1;
1405   Int_t nBkgrdFiles = fBkgrdFileNames->GetEntriesFast();
1406   if (nBkgrdFiles == 0) return 1;
1407
1408   // get the number of signal events
1409   if (nEvents <= 0) {
1410     AliRunLoader* runLoader =
1411         AliRunLoader::Open(fGAliceFileName.Data(), "SIGNAL");
1412     if (!runLoader) return 1;
1413
1414     nEvents = runLoader->GetNumberOfEvents();
1415     delete runLoader;
1416   }
1417
1418   Int_t result = 0;
1419   for (Int_t iBkgrdFile = 0; iBkgrdFile < nBkgrdFiles; iBkgrdFile++) {
1420     // get the number of background events
1421     const char* fileName = ((TObjString*)
1422                             (fBkgrdFileNames->At(iBkgrdFile)))->GetName();
1423     AliRunLoader* runLoader =
1424       AliRunLoader::Open(fileName, "BKGRD");
1425     if (!runLoader) continue;
1426     Int_t nBkgrdEvents = runLoader->GetNumberOfEvents();
1427     delete runLoader;
1428
1429     // get or calculate the number of signal per background events
1430     Int_t nSignalPerBkgrd = fBkgrdFileNames->At(iBkgrdFile)->GetUniqueID();
1431     if (nSignalPerBkgrd <= 0) {
1432       nSignalPerBkgrd = (nEvents-1) / nBkgrdEvents + 1;
1433     } else if (result && (result != nSignalPerBkgrd)) {
1434       AliInfo(Form("the number of signal events per background event "
1435                    "will be changed from %d to %d for stream %d",
1436                    nSignalPerBkgrd, result, iBkgrdFile+1));
1437       nSignalPerBkgrd = result;
1438     }
1439
1440     if (!result) result = nSignalPerBkgrd;
1441     if (nSignalPerBkgrd * nBkgrdEvents < nEvents) {
1442       AliWarning(Form("not enough background events (%d) for %d signal events "
1443                       "using %d signal per background events for stream %d",
1444                       nBkgrdEvents, nEvents, nSignalPerBkgrd, iBkgrdFile+1));
1445     }
1446   }
1447
1448   return result;
1449 }
1450
1451 //_____________________________________________________________________________
1452 Bool_t AliSimulation::IsSelected(TString detName, TString& detectors) const
1453 {
1454 // check whether detName is contained in detectors
1455 // if yes, it is removed from detectors
1456
1457   // check if all detectors are selected
1458   if ((detectors.CompareTo("ALL") == 0) ||
1459       detectors.BeginsWith("ALL ") ||
1460       detectors.EndsWith(" ALL") ||
1461       detectors.Contains(" ALL ")) {
1462     detectors = "ALL";
1463     return kTRUE;
1464   }
1465
1466   // search for the given detector
1467   Bool_t result = kFALSE;
1468   if ((detectors.CompareTo(detName) == 0) ||
1469       detectors.BeginsWith(detName+" ") ||
1470       detectors.EndsWith(" "+detName) ||
1471       detectors.Contains(" "+detName+" ")) {
1472     detectors.ReplaceAll(detName, "");
1473     result = kTRUE;
1474   }
1475
1476   // clean up the detectors string
1477   while (detectors.Contains("  ")) detectors.ReplaceAll("  ", " ");
1478   while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
1479   while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
1480
1481   return result;
1482 }
1483
1484 //_____________________________________________________________________________
1485 Bool_t AliSimulation::ConvertRaw2SDigits(const char* rawDirectory, const char* esdFileName)
1486 {
1487 //
1488 // Steering routine  to convert raw data in directory rawDirectory/ to fake SDigits.
1489 // These can be used for embedding of MC tracks into RAW data using the standard
1490 // merging procedure.
1491 //
1492 // If an ESD file is given the reconstructed vertex is taken from it and stored in the event header.
1493 //
1494     if (!gAlice) {
1495         AliError("no gAlice object. Restart aliroot and try again.");
1496         return kFALSE;
1497     }
1498     if (gAlice->Modules()->GetEntries() > 0) {
1499         AliError("gAlice was already run. Restart aliroot and try again.");
1500         return kFALSE;
1501     }
1502
1503     AliInfo(Form("initializing gAlice with config file %s",fConfigFileName.Data()));
1504     StdoutToAliInfo(StderrToAliError(gAlice->Init(fConfigFileName.Data());););
1505 //
1506 //  Initialize CDB
1507     InitCDB();
1508     //AliCDBManager* man = AliCDBManager::Instance();
1509     //man->SetRun(0); // Should this come from rawdata header ?
1510
1511     Int_t iDet;
1512     //
1513     // Get the runloader
1514     AliRunLoader* runLoader = gAlice->GetRunLoader();
1515     //
1516     // Open esd file if available
1517     TFile* esdFile = TFile::Open(esdFileName);
1518     Bool_t esdOK = (esdFile != 0);
1519     AliESD* esd = new AliESD;
1520     TTree* treeESD = 0;
1521     if (esdOK) {
1522         treeESD = (TTree*) esdFile->Get("esdTree");
1523         if (!treeESD) {
1524             AliWarning("No ESD tree found");
1525             esdOK = kFALSE;
1526         } else {
1527             treeESD->SetBranchAddress("ESD", &esd);
1528         }
1529     }
1530     //
1531     // Create the RawReader
1532     TString fileName(rawDirectory);
1533     AliRawReader* rawReader = 0x0;
1534     if (fileName.EndsWith("/")) {
1535       rawReader = new AliRawReaderFile(fileName);
1536     } else if (fileName.EndsWith(".root")) {
1537       rawReader = new AliRawReaderRoot(fileName);
1538     } else if (!fileName.IsNull()) {
1539       rawReader = new AliRawReaderDate(fileName);
1540       rawReader->SelectEvents(7);
1541     }
1542 //     if (!fEquipIdMap.IsNull() && fRawReader)
1543 //       fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
1544     //
1545     // Get list of detectors
1546     TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1547     //
1548     // Get Header
1549     AliHeader* header = runLoader->GetHeader();
1550     //
1551     TString detStr = fMakeSDigits;
1552     // Event loop
1553     Int_t nev = 0;
1554     while(kTRUE) {
1555         if (!(rawReader->NextEvent())) break;
1556         //
1557         // Detector loop
1558         for (iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1559             AliModule* det = (AliModule*) detArray->At(iDet);
1560             if (!det || !det->IsActive()) continue;
1561             if (IsSelected(det->GetName(), detStr)) {
1562               AliInfo(Form("Calling Raw2SDigits for %s\n", det->GetName()));
1563               det->Raw2SDigits(rawReader);
1564               rawReader->Reset();
1565             }
1566         } // detectors
1567
1568
1569         //
1570         //  If ESD information available obtain reconstructed vertex and store in header.
1571         if (esdOK) {
1572             treeESD->GetEvent(nev);
1573             const AliESDVertex* esdVertex = esd->GetPrimaryVertex();
1574             Double_t position[3];
1575             esdVertex->GetXYZ(position);
1576             AliGenEventHeader* mcHeader = new  AliGenEventHeader("ESD");
1577             TArrayF mcV;
1578             mcV.Set(3);
1579             for (Int_t i = 0; i < 3; i++) mcV[i] = position[i];
1580             mcHeader->SetPrimaryVertex(mcV);
1581             header->Reset(0,nev);
1582             header->SetGenEventHeader(mcHeader);
1583             printf("***** Saved vertex %f %f %f \n", position[0], position[1], position[2]);
1584         }
1585         nev++;
1586 //
1587 //      Finish the event
1588         runLoader->TreeE()->Fill();
1589         runLoader->SetNextEvent();
1590     } // events
1591
1592     delete rawReader;
1593 //
1594 //  Finish the run
1595     runLoader->CdGAFile();
1596     runLoader->WriteHeader("OVERWRITE");
1597     runLoader->WriteRunLoader();
1598
1599     return kTRUE;
1600 }
1601
1602 //_____________________________________________________________________________
1603 Int_t AliSimulation::GetDetIndex(const char* detector)
1604 {
1605   // return the detector index corresponding to detector
1606   Int_t index = -1 ;
1607   for (index = 0; index < fgkNDetectors ; index++) {
1608     if ( strcmp(detector, fgkDetectorName[index]) == 0 )
1609           break ;
1610   }
1611   return index ;
1612 }
1613
1614 //_____________________________________________________________________________
1615 Bool_t AliSimulation::RunHLT()
1616 {
1617   // Run the HLT simulation
1618   // HLT simulation is implemented in HLT/sim/AliHLTSimulation
1619   // Disabled if fRunHLT is empty, default vaule is "default".
1620   // AliSimulation::SetRunHLT can be used to set the options for HLT simulation
1621   // The default simulation depends on the HLT component libraries and their
1622   // corresponding agents which define components and chains to run. See
1623   // http://web.ift.uib.no/~kjeks/doc/alice-hlt/
1624   // http://web.ift.uib.no/~kjeks/doc/alice-hlt/classAliHLTModuleAgent.html
1625   //
1626   // The libraries to be loaded can be specified as an option.
1627   // <pre>
1628   // AliSimulation sim;
1629   // sim.SetRunHLT("libAliHLTSample.so");
1630   // </pre>
1631   // will only load <tt>libAliHLTSample.so</tt>
1632
1633   // Other available options:
1634   // \li loglevel=<i>level</i> <br>
1635   //     logging level for this processing
1636   // \li alilog=off
1637   //     disable redirection of log messages to AliLog class
1638   // \li config=<i>macro</i>
1639   //     configuration macro
1640   // \li localrec=<i>configuration</i>
1641   //     comma separated list of configurations to be run during simulation
1642
1643   int iResult=0;
1644   AliRunLoader* pRunLoader = LoadRun("READ");
1645   if (!pRunLoader) return kFALSE;
1646
1647   // initialize CDB storage, run number, set CDB lock
1648   InitCDB();
1649   if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
1650   SetCDBLock();
1651
1652   // load the library dynamically
1653   gSystem->Load(ALIHLTSIMULATION_LIBRARY);
1654
1655   // check for the library version
1656   AliHLTSimulationGetLibraryVersion_t fctVersion=(AliHLTSimulationGetLibraryVersion_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_GET_LIBRARY_VERSION));
1657   if (!fctVersion) {
1658     AliError(Form("can not load library %s", ALIHLTSIMULATION_LIBRARY));
1659     return kFALSE;
1660   }
1661   if (fctVersion()!= ALIHLTSIMULATION_LIBRARY_VERSION) {
1662     AliError(Form("%s version does not match: compiled for version %d, loaded %d", ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_LIBRARY_VERSION, fctVersion()));
1663     return kFALSE;
1664   }
1665
1666   // print compile info
1667   typedef void (*CompileInfo)( char*& date, char*& time);
1668   CompileInfo fctInfo=(CompileInfo)gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, "CompileInfo");
1669   if (fctInfo) {
1670     char* date="";
1671     char* time="";
1672     (*fctInfo)(date, time);
1673     if (!date) date="unknown";
1674     if (!time) time="unknown";
1675     AliInfo(Form("%s build on %s (%s)", ALIHLTSIMULATION_LIBRARY, date, time));
1676   } else {
1677     AliInfo(Form("no build info available for %s", ALIHLTSIMULATION_LIBRARY));
1678   }
1679
1680   // create instance of the HLT simulation
1681   AliHLTSimulationCreateInstance_t fctCreate=(AliHLTSimulationCreateInstance_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_CREATE_INSTANCE));
1682   AliHLTSimulation* pHLT=NULL;
1683   if (fctCreate==NULL || (pHLT=(fctCreate()))==NULL) {
1684     AliError(Form("can not create instance of HLT simulation (creator %p)", fctCreate));
1685     return kFALSE;
1686   }
1687
1688   // init the HLT simulation
1689   if (fRunHLT.CompareTo("default")==0) fRunHLT="";
1690   AliHLTSimulationInit_t fctInit=(AliHLTSimulationInit_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_INIT));
1691   if (fctInit==NULL || (iResult=(fctInit(pHLT, pRunLoader, fRunHLT.Data())))<0) {
1692     AliError(Form("can not init HLT simulation: error %d (init %p)", iResult, fctInit));
1693   } else {
1694     // run the HLT simulation
1695     AliHLTSimulationRun_t fctRun=(AliHLTSimulationRun_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_RUN));
1696     if (fctRun==NULL || (iResult=(fctRun(pHLT, pRunLoader)))<0) {
1697       AliError(Form("can not run HLT simulation: error %d (run %p)", iResult, fctRun));
1698     }
1699   }
1700
1701   // delete the instance
1702   AliHLTSimulationDeleteInstance_t fctDelete=(AliHLTSimulationDeleteInstance_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_DELETE_INSTANCE));
1703   if (fctDelete==NULL || fctDelete(pHLT)<0) {
1704     AliError(Form("can not delete instance of HLT simulation (creator %p)", fctDelete));
1705   }
1706   pHLT=NULL;
1707
1708   return iResult>=0?kTRUE:kFALSE;
1709 }
1710
1711 //_____________________________________________________________________________
1712 Bool_t AliSimulation::RunQA()
1713 {
1714         // run the QA on summable hits, digits or digits
1715
1716         AliQADataMakerSteer qas ;
1717     qas.SetRunLoader(gAlice->GetRunLoader()) ;
1718
1719         Bool_t rv =  qas.Run("ALL", AliQA::kHITS) ;
1720 //      qas.Reset() ;
1721         rv *= qas.Run(fMakeSDigits.Data(), AliQA::kSDIGITS) ;
1722 //      qas.Reset() ;
1723         rv *= qas.Run(fMakeDigits.Data(), AliQA::kDIGITS) ;
1724 //      qas.Reset() ;
1725         rv *= qas.Run(fMakeDigitsFromHits.Data(), AliQA::kDIGITS) ;
1726
1727         return rv ;
1728 }
1729
1730 //_____________________________________________________________________________
1731 void AliSimulation::ProcessEnvironmentVars()
1732 {
1733 // Extract run number and random generator seed from env variables
1734
1735     AliInfo("Processing environment variables");
1736
1737     // Random Number seed
1738
1739     // first check that seed is not already set
1740     if (fSeed == 0) {
1741         if (gSystem->Getenv("CONFIG_SEED")) {
1742                 fSeed = atoi(gSystem->Getenv("CONFIG_SEED"));
1743         }
1744     } else {
1745         if (gSystem->Getenv("CONFIG_SEED")) {
1746                 AliInfo(Form("Seed for random number generation already set (%d)"
1747                              ": CONFIG_SEED variable ignored!", fSeed));
1748         }
1749     }
1750
1751     AliInfo(Form("Seed for random number generation = %d ", fSeed));
1752
1753     // Run Number
1754
1755     // first check that run number is not already set
1756     if(fRun < 0) {
1757         if (gSystem->Getenv("DC_RUN")) {
1758                 fRun = atoi(gSystem->Getenv("DC_RUN"));
1759         }
1760     } else {
1761         if (gSystem->Getenv("DC_RUN")) {
1762                 AliInfo(Form("Run number already set (%d): DC_RUN variable ignored!", fRun));
1763         }
1764     }
1765
1766     AliInfo(Form("Run number = %d", fRun));
1767 }