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