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 <TGeoManager.h>
 109 #include <TObjString.h>
 110 #include <TStopwatch.h>
 111 #include <TSystem.h>
 112 #include <TFile.h>
 113
 114 #include "AliCDBStorage.h"
 115 #include "AliCDBEntry.h"
 116 #include "AliCDBManager.h"
 117 #include "AliAlignObj.h"
 118 #include "AliCentralTrigger.h"
 119 #include "AliDAQ.h"
 120 #include "AliDigitizer.h"
 121 #include "AliGenerator.h"
 122 #include "AliLog.h"
 123 #include "AliModule.h"
 124 #include "AliRun.h"
 125 #include "AliRunDigitizer.h"
 126 #include "AliRunLoader.h"
 127 #include "AliSimulation.h"
 128 #include "AliVertexGenFile.h"
 129 #include "AliCentralTrigger.h"
 130 #include "AliCTPRawData.h"
 131 #include "AliRawReaderFile.h"
 132 #include "AliESD.h"
 133 #include "AliHeader.h"
 134 #include "AliGenEventHeader.h"
 135
 136 ClassImp(AliSimulation)
 137
 138
 139 //_____________________________________________________________________________
 140 AliSimulation::AliSimulation(const char* configFileName, const char* cdbUri,
 141                              const char* name, const char* title) :
 142   TNamed(name, title),
 143
 144   fRunGeneration(kTRUE),
 145   fRunSimulation(kTRUE),
 146   fLoadAlignFromCDB(kTRUE),
 147   fLoadAlignData("ALL"),
 148   fMakeSDigits("ALL"),
 149   fMakeDigits("ALL"),
 150   fMakeTrigger(""),
 151   fMakeDigitsFromHits(""),
 152   fWriteRawData(""),
 153   fRawDataFileName(""),
 154   fDeleteIntermediateFiles(kFALSE),
 155   fStopOnError(kFALSE),
 156
 157   fNEvents(1),
 158   fConfigFileName(configFileName),
 159   fGAliceFileName("galice.root"),
 160   fEventsPerFile(),
 161   fBkgrdFileNames(NULL),
 162   fAlignObjArray(NULL),
 163   fUseBkgrdVertex(kTRUE),
 164   fRegionOfInterest(kFALSE),
 165   fCDBUri(cdbUri),
 166   fSpecCDBUri(),
 167   fEmbeddingFlag(kFALSE)
 168 {
 169 // create simulation object with default parameters
 170
 171   SetGAliceFile("galice.root");
 172 }
 173
 174 //_____________________________________________________________________________
 175 AliSimulation::AliSimulation(const AliSimulation& sim) :
 176   TNamed(sim),
 177
 178   fRunGeneration(sim.fRunGeneration),
 179   fRunSimulation(sim.fRunSimulation),
 180   fLoadAlignFromCDB(sim.fLoadAlignFromCDB),
 181   fLoadAlignData(sim.fLoadAlignData),
 182   fMakeSDigits(sim.fMakeSDigits),
 183   fMakeDigits(sim.fMakeDigits),
 184   fMakeTrigger(sim.fMakeTrigger),
 185   fMakeDigitsFromHits(sim.fMakeDigitsFromHits),
 186   fWriteRawData(sim.fWriteRawData),
 187   fRawDataFileName(""),
 188   fDeleteIntermediateFiles(kFALSE),
 189   fStopOnError(sim.fStopOnError),
 190
 191   fNEvents(sim.fNEvents),
 192   fConfigFileName(sim.fConfigFileName),
 193   fGAliceFileName(sim.fGAliceFileName),
 194   fEventsPerFile(),
 195   fBkgrdFileNames(NULL),
 196   fAlignObjArray(NULL),
 197   fUseBkgrdVertex(sim.fUseBkgrdVertex),
 198   fRegionOfInterest(sim.fRegionOfInterest),
 199   fCDBUri(sim.fCDBUri),
 200   fSpecCDBUri(),
 201   fEmbeddingFlag(sim.fEmbeddingFlag)
 202 {
 203 // copy constructor
 204
 205   for (Int_t i = 0; i < sim.fEventsPerFile.GetEntriesFast(); i++) {
 206     if (!sim.fEventsPerFile[i]) continue;
 207     fEventsPerFile.Add(sim.fEventsPerFile[i]->Clone());
 208   }
 209
 210   fBkgrdFileNames = new TObjArray;
 211   for (Int_t i = 0; i < sim.fBkgrdFileNames->GetEntriesFast(); i++) {
 212     if (!sim.fBkgrdFileNames->At(i)) continue;
 213     fBkgrdFileNames->Add(sim.fBkgrdFileNames->At(i)->Clone());
 214   }
 215
 216   for (Int_t i = 0; i < sim.fSpecCDBUri.GetEntriesFast(); i++) {
 217     if (sim.fSpecCDBUri[i]) fSpecCDBUri.Add(sim.fSpecCDBUri[i]->Clone());
 218   }
 219
 220 }
 221
 222 //_____________________________________________________________________________
 223 AliSimulation& AliSimulation::operator = (const AliSimulation& sim)
 224 {
 225 // assignment operator
 226
 227   this->~AliSimulation();
 228   new(this) AliSimulation(sim);
 229   return *this;
 230 }
 231
 232 //_____________________________________________________________________________
 233 AliSimulation::~AliSimulation()
 234 {
 235 // clean up
 236
 237   fEventsPerFile.Delete();
 238 //  if(fAlignObjArray) fAlignObjArray->Delete(); // fAlignObjArray->RemoveAll() ???
 239 //  delete fAlignObjArray; fAlignObjArray=0;
 240
 241   if (fBkgrdFileNames) {
 242     fBkgrdFileNames->Delete();
 243     delete fBkgrdFileNames;
 244   }
 245
 246   fSpecCDBUri.Delete();
 247 }
 248
 249
 250 //_____________________________________________________________________________
 251 void AliSimulation::SetNumberOfEvents(Int_t nEvents)
 252 {
 253 // set the number of events for one run
 254
 255   fNEvents = nEvents;
 256 }
 257
 258 //_____________________________________________________________________________
 259 void AliSimulation::InitCDBStorage()
 260 {
 261 // activate a default CDB storage
 262 // First check if we have any CDB storage set, because it is used
 263 // to retrieve the calibration and alignment constants
 264
 265   AliCDBManager* man = AliCDBManager::Instance();
 266   if (man->IsDefaultStorageSet())
 267   {
 268     AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 269     AliWarning("Default CDB storage has been already set !");
 270     AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fCDBUri.Data()));
 271     AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 272     fCDBUri = "";
 273   }
 274   else {
 275     AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 276     AliWarning(Form("Default CDB storage is set to: %s",fCDBUri.Data()));
 277     AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 278     man->SetDefaultStorage(fCDBUri);
 279   }
 280
 281   // Now activate the detector specific CDB storage locations
 282   for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
 283     TObject* obj = fSpecCDBUri[i];
 284     if (!obj) continue;
 285     AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 286     AliWarning(Form("Specific CDB storage for %s is set to: %s",obj->GetName(),obj->GetTitle()));
 287     AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 288     man->SetSpecificStorage(obj->GetName(),obj->GetTitle());
 289   }
 290   man->Print();
 291 }
 292
 293 //_____________________________________________________________________________
 294 void AliSimulation::SetDefaultStorage(const char* uri) {
 295 // Store the desired default CDB storage location
 296 // Activate it later within the Run() method
 297
 298   fCDBUri = uri;
 299
 300 }
 301
 302 //_____________________________________________________________________________
 303 void AliSimulation::SetSpecificStorage(const char* detName, const char* uri) {
 304 // Store a detector-specific CDB storage location
 305 // Activate it later within the Run() method
 306
 307   TObject* obj = fSpecCDBUri.FindObject(detName);
 308   if (obj) fSpecCDBUri.Remove(obj);
 309   fSpecCDBUri.Add(new TNamed(detName, uri));
 310
 311 }
 312
 313 //_____________________________________________________________________________
 314 void AliSimulation::SetConfigFile(const char* fileName)
 315 {
 316 // set the name of the config file
 317
 318   fConfigFileName = fileName;
 319 }
 320
 321 //_____________________________________________________________________________
 322 void AliSimulation::SetGAliceFile(const char* fileName)
 323 {
 324 // set the name of the galice file
 325 // the path is converted to an absolute one if it is relative
 326
 327   fGAliceFileName = fileName;
 328   if (!gSystem->IsAbsoluteFileName(fGAliceFileName)) {
 329     char* absFileName = gSystem->ConcatFileName(gSystem->WorkingDirectory(),
 330                                                 fGAliceFileName);
 331     fGAliceFileName = absFileName;
 332     delete[] absFileName;
 333   }
 334
 335   AliDebug(2, Form("galice file name set to %s", fileName));
 336 }
 337
 338 //_____________________________________________________________________________
 339 void AliSimulation::SetEventsPerFile(const char* detector, const char* type,
 340                                      Int_t nEvents)
 341 {
 342 // set the number of events per file for the given detector and data type
 343 // ("Hits", "Summable Digits", "Digits", "Reconstructed Points" or "Tracks")
 344
 345   TNamed* obj = new TNamed(detector, type);
 346   obj->SetUniqueID(nEvents);
 347   fEventsPerFile.Add(obj);
 348 }
 349
 350 //_____________________________________________________________________________
 351 Bool_t AliSimulation::ApplyAlignObjsToGeom(TObjArray* alObjArray)
 352 {
 353   // Read collection of alignment objects (AliAlignObj derived) saved
 354   // in the TClonesArray ClArrayName and apply them to the geometry
 355   // manager singleton.
 356   //
 357   alObjArray->Sort();
 358   Int_t nvols = alObjArray->GetEntriesFast();
 359
 360   Bool_t flag = kTRUE;
 361
 362   for(Int_t j=0; j<nvols; j++)
 363     {
 364       AliAlignObj* alobj = (AliAlignObj*) alObjArray->UncheckedAt(j);
 365       if (alobj->ApplyToGeometry() == kFALSE) flag = kFALSE;
 366     }
 367
 368   if (AliDebugLevelClass() >= 1) {
 369     gGeoManager->GetTopNode()->CheckOverlaps(20);
 370     TObjArray* ovexlist = gGeoManager->GetListOfOverlaps();
 371     if(ovexlist->GetEntriesFast()){
 372       AliError("The application of alignment objects to the geometry caused huge overlaps/extrusions!");
 373    }
 374   }
 375
 376   return flag;
 377
 378 }
 379
 380 //_____________________________________________________________________________
 381 Bool_t AliSimulation::ApplyAlignObjsToGeom(const char* fileName, const char* clArrayName)
 382 {
 383   // read collection of alignment objects (AliAlignObj derived) saved
 384   // in the TClonesArray ClArrayName in the file fileName and apply
 385   // them to the TGeo geometry passed as argument
 386   //
 387
 388   TFile* inFile = TFile::Open(fileName,"READ");
 389   if (!inFile || !inFile->IsOpen()) {
 390     AliErrorClass(Form("Could not open file %s !",fileName));
 391     return kFALSE;
 392   }
 393
 394   TClonesArray* alObjArray = ((TClonesArray*) inFile->Get(clArrayName));
 395   inFile->Close();
 396   if (!alObjArray) {
 397     AliErrorClass(Form("Could not get array (%s) from file (%s) !",clArrayName,fileName));
 398     return kFALSE;
 399   }
 400
 401   return ApplyAlignObjsToGeom(alObjArray);
 402
 403 }
 404
 405 //_____________________________________________________________________________
 406 Bool_t AliSimulation::ApplyAlignObjsToGeom(AliCDBParam* param, AliCDBId& Id)
 407 {
 408   // read collection of alignment objects (AliAlignObj derived) saved
 409   // in the TClonesArray ClArrayName in the AliCDBEntry identified by
 410   // param (to get the AliCDBStorage) and Id; apply the alignment objects
 411   // to the TGeo geometry passed as argument
 412   //
 413
 414   AliCDBStorage* storage = AliCDBManager::Instance()->GetStorage(param);
 415   AliCDBEntry* entry = storage->Get(Id);
 416   TClonesArray* AlObjArray = ((TClonesArray*) entry->GetObject());
 417
 418   return ApplyAlignObjsToGeom(AlObjArray);
 419
 420 }
 421
 422 //_____________________________________________________________________________
 423 Bool_t AliSimulation::ApplyAlignObjsToGeom(const char* uri, const char* path, Int_t runnum, Int_t version, Int_t sversion)
 424 {
 425   // read collection of alignment objects (AliAlignObj derived) saved
 426   // in the TClonesArray ClArrayName in the AliCDBEntry identified by
 427   // param (to get the AliCDBStorage) and Id; apply the alignment objects
 428   // to the TGeo geometry passed as argument
 429   //
 430
 431   AliCDBParam* param = AliCDBManager::Instance()->CreateParameter(uri);
 432   AliCDBId id(path, runnum, runnum, version, sversion);
 433
 434   return ApplyAlignObjsToGeom(param, id);
 435
 436 }
 437
 438 //_____________________________________________________________________________
 439 Bool_t AliSimulation::ApplyAlignObjsToGeom(const char* detName, Int_t runnum, Int_t version, Int_t sversion)
 440 {
 441   // read collection of alignment objects (AliAlignObj derived) saved
 442   // in the TClonesArray ClArrayName in the AliCDBEntry identified by
 443   // param (to get the AliCDBStorage) and Id; apply the alignment objects
 444   // to the TGeo geometry passed as argument
 445   //
 446
 447   AliCDBPath path(detName,"Align","Data");
 448   AliCDBEntry* entry = AliCDBManager::Instance()->Get(path.GetPath(),runnum,version,sversion);
 449
 450   if(!entry) return kFALSE;
 451   TClonesArray* AlObjArray = ((TClonesArray*) entry->GetObject());
 452
 453   return ApplyAlignObjsToGeom(AlObjArray);
 454 }
 455
 456 //_____________________________________________________________________________
 457 Bool_t AliSimulation::SetAlignObjArraySingleDet(const char* detName)
 458 {
 459   // Fills array of single detector's alignable objects from CDB
 460
 461   AliDebug(2, Form("Loading alignment data for detector: %s",detName));
 462
 463   AliCDBEntry *entry;
 464
 465   AliCDBPath path(detName,"Align","Data");
 466
 467   entry=AliCDBManager::Instance()->Get(path.GetPath());
 468   if(!entry){
 469         AliDebug(2,Form("Couldn't load alignment data for detector %s",detName));
 470         return kFALSE;
 471   }
 472   entry->SetOwner(1);
 473   TClonesArray *alignArray = (TClonesArray*) entry->GetObject();
 474   alignArray->SetOwner(0);
 475   AliDebug(2,Form("Found %d alignment objects for %s",
 476                         alignArray->GetEntries(),detName));
 477
 478   AliAlignObj *alignObj=0;
 479   TIter iter(alignArray);
 480
 481   // loop over align objects in detector
 482   while( ( alignObj=(AliAlignObj *) iter.Next() ) ){
 483         fAlignObjArray->Add(alignObj);
 484   }
 485   // delete entry --- Don't delete, it is cached!
 486
 487   AliDebug(2, Form("fAlignObjArray entries: %d",fAlignObjArray->GetEntries() ));
 488   return kTRUE;
 489
 490 }
 491
 492 //_____________________________________________________________________________
 493 Bool_t AliSimulation::MisalignGeometry(AliRunLoader *runLoader)
 494 {
 495   // Read the alignment objects from CDB.
 496   // Each detector is supposed to have the
 497   // alignment objects in DET/Align/Data CDB path.
 498   // All the detector objects are then collected,
 499   // sorted by geometry level (starting from ALIC) and
 500   // then applied to the TGeo geometry.
 501   // Finally an overlaps check is performed.
 502
 503   Bool_t delRunLoader = kFALSE;
 504   if (!runLoader) {
 505     runLoader = LoadRun("READ");
 506     if (!runLoader) return kFALSE;
 507     delRunLoader = kTRUE;
 508   }
 509
 510   // Load alignment data from CDB and fill fAlignObjArray
 511   if(fLoadAlignFromCDB){
 512         if(!fAlignObjArray) fAlignObjArray = new TObjArray();
 513
 514         //fAlignObjArray->RemoveAll();
 515         fAlignObjArray->Clear();
 516         fAlignObjArray->SetOwner(0);
 517
 518         TString detStr = fLoadAlignData;
 519         TString dataNotLoaded="";
 520         TString dataLoaded="";
 521
 522         TObjArray* detArray = runLoader->GetAliRun()->Detectors();
 523         for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
 524                 AliModule* det = (AliModule*) detArray->At(iDet);
 525                 if (!det || !det->IsActive()) continue;
 526                 if (IsSelected(det->GetName(), detStr)) {
 527                         if(!SetAlignObjArraySingleDet(det->GetName())){
 528                                 dataNotLoaded += det->GetName();
 529                                 dataNotLoaded += " ";
 530                         } else {
 531                                 dataLoaded += det->GetName();
 532                                 dataLoaded += " ";
 533                         }
 534                 }
 535         } // end loop over detectors
 536
 537         if ((detStr.CompareTo("ALL") == 0)) detStr = "";
 538         dataNotLoaded += detStr;
 539         AliInfo(Form("Alignment data loaded for: %s",
 540                           dataLoaded.Data()));
 541         AliInfo(Form("Didn't/couldn't load alignment data for: %s",
 542                           dataNotLoaded.Data()));
 543   } // fLoadAlignFromCDB flag
 544
 545   // Check if the array with alignment objects was
 546   // provided by the user. If yes, apply the objects
 547   // to the present TGeo geometry
 548   if (fAlignObjArray) {
 549     if (gGeoManager && gGeoManager->IsClosed()) {
 550       if (ApplyAlignObjsToGeom(fAlignObjArray) == kFALSE) {
 551         AliError("The misalignment of one or more volumes failed!"
 552                  "Compare the list of simulated detectors and the list of detector alignment data!");
 553         if (delRunLoader) delete runLoader;
 554         return kFALSE;
 555       }
 556     }
 557     else {
 558       AliError("Can't apply the misalignment! gGeoManager doesn't exist or it is still opened!");
 559       if (delRunLoader) delete runLoader;
 560       return kFALSE;
 561     }
 562   }
 563
 564   if (delRunLoader) delete runLoader;
 565
 566   return kTRUE;
 567 }
 568
 569
 570 //_____________________________________________________________________________
 571 Bool_t AliSimulation::SetRunNumber()
 572 {
 573   // Set the CDB manager run number
 574   // The run number is retrieved from gAlice
 575
 576   if(AliCDBManager::Instance()->GetRun() < 0) {
 577     AliRunLoader* runLoader = LoadRun("READ");
 578     if (!runLoader) return kFALSE;
 579     else {
 580       AliCDBManager::Instance()->SetRun(runLoader->GetAliRun()->GetRunNumber());
 581       AliInfo(Form("Run number: %d",AliCDBManager::Instance()->GetRun()));
 582       delete runLoader;
 583     }
 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   InitCDBStorage();
 612
 613   if (nEvents > 0) fNEvents = nEvents;
 614
 615   // generation and simulation -> hits
 616   if (fRunGeneration) {
 617     if (!RunSimulation()) if (fStopOnError) return kFALSE;
 618   }
 619
 620   // Set run number in CDBManager (if it is not already set in RunSimulation)
 621   if (!SetRunNumber()) if (fStopOnError) return kFALSE;
 622
 623   // Load and misalign the geometry
 624   if (!gGeoManager) {
 625     TGeoManager::Import("geometry.root");
 626     if (!gGeoManager) if (fStopOnError) return kFALSE;
 627     if (!MisalignGeometry()) if (fStopOnError) return kFALSE;
 628   }
 629
 630   // hits -> summable digits
 631   if (!fMakeSDigits.IsNull()) {
 632     if (!RunSDigitization(fMakeSDigits)) if (fStopOnError) return kFALSE;
 633   }
 634
 635   // summable digits -> digits
 636   if (!fMakeDigits.IsNull()) {
 637     if (!RunDigitization(fMakeDigits, fMakeDigitsFromHits)) {
 638       if (fStopOnError) return kFALSE;
 639     }
 640   }
 641
 642   // hits -> digits
 643   if (!fMakeDigitsFromHits.IsNull()) {
 644     if (fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
 645       AliWarning(Form("Merging and direct creation of digits from hits "
 646                  "was selected for some detectors. "
 647                  "No merging will be done for the following detectors: %s",
 648                  fMakeDigitsFromHits.Data()));
 649     }
 650     if (!RunHitsDigitization(fMakeDigitsFromHits)) {
 651       if (fStopOnError) return kFALSE;
 652     }
 653   }
 654
 655   // digits -> trigger
 656   if (!RunTrigger(fMakeTrigger)) {
 657     if (fStopOnError) return kFALSE;
 658   }
 659
 660   // digits -> raw data
 661   if (!fWriteRawData.IsNull()) {
 662     if (!WriteRawData(fWriteRawData, fRawDataFileName,
 663                       fDeleteIntermediateFiles)) {
 664       if (fStopOnError) return kFALSE;
 665     }
 666   }
 667
 668   return kTRUE;
 669 }
 670
 671 //_____________________________________________________________________________
 672 Bool_t AliSimulation::RunTrigger(const char* descriptors)
 673 {
 674   // run the trigger
 675
 676    TStopwatch stopwatch;
 677    stopwatch.Start();
 678
 679    AliRunLoader* runLoader = LoadRun("READ");
 680    if (!runLoader) return kFALSE;
 681    TString des = descriptors;
 682
 683    if (des.IsNull()) {
 684      if (gAlice->GetTriggerDescriptor() != "") {
 685        des = gAlice->GetTriggerDescriptor();
 686      }
 687      else {
 688        AliWarning("No trigger descriptor is specified. Skipping the trigger simulation...");
 689        return kTRUE;
 690      }
 691    }
 692
 693    runLoader->MakeTree( "CT" );
 694    AliCentralTrigger* aCTP = runLoader->GetTrigger();
 695   // Load Descriptors
 696    aCTP->LoadDescriptor( des );
 697
 698   // digits -> trigger
 699    if( !aCTP->RunTrigger( runLoader ) ) {
 700       if (fStopOnError) {
 701     //  delete aCTP;
 702          return kFALSE;
 703       }
 704    }
 705
 706    AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
 707            stopwatch.RealTime(),stopwatch.CpuTime()));
 708
 709    delete runLoader;
 710
 711    return kTRUE;
 712 }
 713
 714 //_____________________________________________________________________________
 715 Bool_t AliSimulation::WriteTriggerRawData()
 716 {
 717   // Writes the CTP (trigger) DDL raw data
 718   // Details of the format are given in the
 719   // trigger TDR - pages 134 and 135.
 720   AliCTPRawData writer;
 721   writer.RawData();
 722
 723   return kTRUE;
 724 }
 725
 726 //_____________________________________________________________________________
 727 Bool_t AliSimulation::RunSimulation(Int_t nEvents)
 728 {
 729 // run the generation and simulation
 730
 731   TStopwatch stopwatch;
 732   stopwatch.Start();
 733
 734   if (!gAlice) {
 735     AliError("no gAlice object. Restart aliroot and try again.");
 736     return kFALSE;
 737   }
 738   if (gAlice->Modules()->GetEntries() > 0) {
 739     AliError("gAlice was already run. Restart aliroot and try again.");
 740     return kFALSE;
 741   }
 742
 743   AliInfo(Form("initializing gAlice with config file %s",
 744           fConfigFileName.Data()));
 745   StdoutToAliInfo(StderrToAliError(
 746     gAlice->Init(fConfigFileName.Data());
 747   ););
 748
 749   // Get the trigger descriptor string
 750   // Either from AliSimulation or from
 751   // gAlice
 752   if (fMakeTrigger.IsNull()) {
 753     if (gAlice->GetTriggerDescriptor() != "")
 754       fMakeTrigger = gAlice->GetTriggerDescriptor();
 755   }
 756   else
 757     gAlice->SetTriggerDescriptor(fMakeTrigger.Data());
 758
 759   // Set run number in CDBManager
 760   AliCDBManager::Instance()->SetRun(gAlice->GetRunNumber());
 761   AliInfo(Form("Run number: %d",AliCDBManager::Instance()->GetRun()));
 762
 763   AliRunLoader* runLoader = gAlice->GetRunLoader();
 764   if (!runLoader) {
 765              AliError(Form("gAlice has no run loader object. "
 766                              "Check your config file: %s", fConfigFileName.Data()));
 767              return kFALSE;
 768   }
 769   SetGAliceFile(runLoader->GetFileName());
 770
 771   // Export ideal geometry
 772   if (gGeoManager) gGeoManager->Export("geometry.root");
 773
 774   // Misalign geometry
 775 //   if (!MisalignGeometry(runLoader)) {
 776 //     delete runLoader;
 777 //     return kFALSE;
 778 //   }
 779   MisalignGeometry(runLoader);
 780
 781   // Export (mis)aligned geometry
 782   if (gGeoManager) gGeoManager->Export("misaligned_geometry.root");
 783
 784 //   AliRunLoader* runLoader = gAlice->GetRunLoader();
 785 //   if (!runLoader) {
 786 //     AliError(Form("gAlice has no run loader object. "
 787 //                   "Check your config file: %s", fConfigFileName.Data()));
 788 //     return kFALSE;
 789 //   }
 790 //   SetGAliceFile(runLoader->GetFileName());
 791
 792   if (!gAlice->Generator()) {
 793     AliError(Form("gAlice has no generator object. "
 794                   "Check your config file: %s", fConfigFileName.Data()));
 795     return kFALSE;
 796   }
 797   if (nEvents <= 0) nEvents = fNEvents;
 798
 799   // get vertex from background file in case of merging
 800   if (fUseBkgrdVertex &&
 801       fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
 802     Int_t signalPerBkgrd = GetNSignalPerBkgrd(nEvents);
 803     const char* fileName = ((TObjString*)
 804                             (fBkgrdFileNames->At(0)))->GetName();
 805     AliInfo(Form("The vertex will be taken from the background "
 806                  "file %s with nSignalPerBackground = %d",
 807                  fileName, signalPerBkgrd));
 808     AliVertexGenFile* vtxGen = new AliVertexGenFile(fileName, signalPerBkgrd);
 809     gAlice->Generator()->SetVertexGenerator(vtxGen);
 810   }
 811
 812   if (!fRunSimulation) {
 813     gAlice->Generator()->SetTrackingFlag(0);
 814   }
 815
 816   // set the number of events per file for given detectors and data types
 817   for (Int_t i = 0; i < fEventsPerFile.GetEntriesFast(); i++) {
 818     if (!fEventsPerFile[i]) continue;
 819     const char* detName = fEventsPerFile[i]->GetName();
 820     const char* typeName = fEventsPerFile[i]->GetTitle();
 821     TString loaderName(detName);
 822     loaderName += "Loader";
 823     AliLoader* loader = runLoader->GetLoader(loaderName);
 824     if (!loader) {
 825       AliError(Form("RunSimulation", "no loader for %s found\n"
 826                     "Number of events per file not set for %s %s",
 827                     detName, typeName, detName));
 828       continue;
 829     }
 830     AliDataLoader* dataLoader =
 831       loader->GetDataLoader(typeName);
 832     if (!dataLoader) {
 833       AliError(Form("no data loader for %s found\n"
 834                     "Number of events per file not set for %s %s",
 835                     typeName, detName, typeName));
 836       continue;
 837     }
 838     dataLoader->SetNumberOfEventsPerFile(fEventsPerFile[i]->GetUniqueID());
 839     AliDebug(1, Form("number of events per file set to %d for %s %s",
 840                      fEventsPerFile[i]->GetUniqueID(), detName, typeName));
 841   }
 842
 843   AliInfo("running gAlice");
 844   StdoutToAliInfo(StderrToAliError(
 845     gAlice->Run(nEvents);
 846   ););
 847
 848   delete runLoader;
 849
 850   AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
 851                stopwatch.RealTime(),stopwatch.CpuTime()));
 852
 853   return kTRUE;
 854 }
 855
 856 //_____________________________________________________________________________
 857 Bool_t AliSimulation::RunSDigitization(const char* detectors)
 858 {
 859 // run the digitization and produce summable digits
 860
 861   TStopwatch stopwatch;
 862   stopwatch.Start();
 863
 864   AliRunLoader* runLoader = LoadRun();
 865   if (!runLoader) return kFALSE;
 866
 867   TString detStr = detectors;
 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     if (IsSelected(det->GetName(), detStr)) {
 873       AliInfo(Form("creating summable digits for %s", det->GetName()));
 874       TStopwatch stopwatchDet;
 875       stopwatchDet.Start();
 876       det->Hits2SDigits();
 877       AliInfo(Form("Execution time for %s: R:%.2fs C:%.2fs",
 878            det->GetName(),stopwatchDet.RealTime(),stopwatchDet.CpuTime()));
 879     }
 880   }
 881
 882   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
 883     AliError(Form("the following detectors were not found: %s",
 884                   detStr.Data()));
 885     if (fStopOnError) return kFALSE;
 886   }
 887
 888   delete runLoader;
 889
 890   AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
 891            stopwatch.RealTime(),stopwatch.CpuTime()));
 892
 893   return kTRUE;
 894 }
 895
 896
 897 //_____________________________________________________________________________
 898 Bool_t AliSimulation::RunDigitization(const char* detectors,
 899                                       const char* excludeDetectors)
 900 {
 901 // run the digitization and produce digits from sdigits
 902
 903   TStopwatch stopwatch;
 904   stopwatch.Start();
 905
 906   while (AliRunLoader::GetRunLoader()) delete AliRunLoader::GetRunLoader();
 907   if (gAlice) delete gAlice;
 908   gAlice = NULL;
 909
 910   Int_t nStreams = 1;
 911   if (fBkgrdFileNames) nStreams = fBkgrdFileNames->GetEntriesFast() + 1;
 912   Int_t signalPerBkgrd = GetNSignalPerBkgrd();
 913   AliRunDigitizer* manager = new AliRunDigitizer(nStreams, signalPerBkgrd);
 914   // manager->SetEmbeddingFlag(fEmbeddingFlag);
 915   manager->SetInputStream(0, fGAliceFileName.Data());
 916   for (Int_t iStream = 1; iStream < nStreams; iStream++) {
 917     const char* fileName = ((TObjString*)
 918                             (fBkgrdFileNames->At(iStream-1)))->GetName();
 919     manager->SetInputStream(iStream, fileName);
 920   }
 921
 922   TString detStr = detectors;
 923   TString detExcl = excludeDetectors;
 924   manager->GetInputStream(0)->ImportgAlice();
 925   AliRunLoader* runLoader =
 926     AliRunLoader::GetRunLoader(manager->GetInputStream(0)->GetFolderName());
 927   TObjArray* detArray = runLoader->GetAliRun()->Detectors();
 928   for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
 929     AliModule* det = (AliModule*) detArray->At(iDet);
 930     if (!det || !det->IsActive()) continue;
 931     if (IsSelected(det->GetName(), detStr) &&
 932         !IsSelected(det->GetName(), detExcl)) {
 933       AliDigitizer* digitizer = det->CreateDigitizer(manager);
 934
 935       if (!digitizer) {
 936         AliError(Form("no digitizer for %s", det->GetName()));
 937         if (fStopOnError) return kFALSE;
 938       } else {
 939         digitizer->SetRegionOfInterest(fRegionOfInterest);
 940       }
 941     }
 942   }
 943
 944   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
 945     AliError(Form("the following detectors were not found: %s",
 946                   detStr.Data()));
 947     if (fStopOnError) return kFALSE;
 948   }
 949
 950   if (!manager->GetListOfTasks()->IsEmpty()) {
 951     AliInfo("executing digitization");
 952     manager->Exec("");
 953   }
 954
 955   delete manager;
 956
 957   AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
 958                stopwatch.RealTime(),stopwatch.CpuTime()));
 959
 960   return kTRUE;
 961 }
 962
 963 //_____________________________________________________________________________
 964 Bool_t AliSimulation::RunHitsDigitization(const char* detectors)
 965 {
 966 // run the digitization and produce digits from hits
 967
 968   TStopwatch stopwatch;
 969   stopwatch.Start();
 970
 971   AliRunLoader* runLoader = LoadRun("READ");
 972   if (!runLoader) return kFALSE;
 973
 974   TString detStr = detectors;
 975   TObjArray* detArray = runLoader->GetAliRun()->Detectors();
 976   for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
 977     AliModule* det = (AliModule*) detArray->At(iDet);
 978     if (!det || !det->IsActive()) continue;
 979     if (IsSelected(det->GetName(), detStr)) {
 980       AliInfo(Form("creating digits from hits for %s", det->GetName()));
 981       det->Hits2Digits();
 982     }
 983   }
 984
 985   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
 986     AliError(Form("the following detectors were not found: %s",
 987                   detStr.Data()));
 988     if (fStopOnError) return kFALSE;
 989   }
 990
 991   delete runLoader;
 992   //PH Temporary fix to avoid interference with the PHOS loder/getter
 993   //PH The problem has to be solved in more general way 09/06/05
 994
 995   AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
 996                stopwatch.RealTime(),stopwatch.CpuTime()));
 997
 998   return kTRUE;
 999 }
1000
1001 //_____________________________________________________________________________
1002 Bool_t AliSimulation::WriteRawData(const char* detectors,
1003                                    const char* fileName,
1004                                    Bool_t deleteIntermediateFiles)
1005 {
1006 // convert the digits to raw data
1007 // First DDL raw data files for the given detectors are created.
1008 // If a file name is given, the DDL files are then converted to a DATE file.
1009 // If deleteIntermediateFiles is true, the DDL raw files are deleted
1010 // afterwards.
1011 // If the file name has the extension ".root", the DATE file is converted
1012 // to a root file.
1013 // If deleteIntermediateFiles is true, the DATE file is deleted afterwards.
1014
1015   TStopwatch stopwatch;
1016   stopwatch.Start();
1017
1018   if (!WriteRawFiles(detectors)) {
1019     if (fStopOnError) return kFALSE;
1020   }
1021
1022   TString dateFileName(fileName);
1023   if (!dateFileName.IsNull()) {
1024     Bool_t rootOutput = dateFileName.EndsWith(".root");
1025     if (rootOutput) dateFileName += ".date";
1026     if (!ConvertRawFilesToDate(dateFileName)) {
1027       if (fStopOnError) return kFALSE;
1028     }
1029     if (deleteIntermediateFiles) {
1030       AliRunLoader* runLoader = LoadRun("READ");
1031       if (runLoader) for (Int_t iEvent = 0;
1032                           iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
1033         char command[256];
1034         sprintf(command, "rm -r raw%d", iEvent);
1035         gSystem->Exec(command);
1036       }
1037     }
1038
1039     if (rootOutput) {
1040       if (!ConvertDateToRoot(dateFileName, fileName)) {
1041         if (fStopOnError) return kFALSE;
1042       }
1043       if (deleteIntermediateFiles) {
1044         gSystem->Unlink(dateFileName);
1045       }
1046     }
1047   }
1048
1049   AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
1050                stopwatch.RealTime(),stopwatch.CpuTime()));
1051
1052   return kTRUE;
1053 }
1054
1055 //_____________________________________________________________________________
1056 Bool_t AliSimulation::WriteRawFiles(const char* detectors)
1057 {
1058 // convert the digits to raw data DDL files
1059
1060   AliRunLoader* runLoader = LoadRun("READ");
1061   if (!runLoader) return kFALSE;
1062
1063   // write raw data to DDL files
1064   for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
1065     AliInfo(Form("processing event %d", iEvent));
1066     runLoader->GetEvent(iEvent);
1067     TString baseDir = gSystem->WorkingDirectory();
1068     char dirName[256];
1069     sprintf(dirName, "raw%d", iEvent);
1070     gSystem->MakeDirectory(dirName);
1071     if (!gSystem->ChangeDirectory(dirName)) {
1072       AliError(Form("couldn't change to directory %s", dirName));
1073       if (fStopOnError) return kFALSE; else continue;
1074     }
1075
1076     TString detStr = detectors;
1077     TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1078     for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1079       AliModule* det = (AliModule*) detArray->At(iDet);
1080       if (!det || !det->IsActive()) continue;
1081       if (IsSelected(det->GetName(), detStr)) {
1082         AliInfo(Form("creating raw data from digits for %s", det->GetName()));
1083         det->Digits2Raw();
1084       }
1085     }
1086
1087     if (!WriteTriggerRawData())
1088       if (fStopOnError) return kFALSE;
1089
1090     gSystem->ChangeDirectory(baseDir);
1091     if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1092       AliError(Form("the following detectors were not found: %s",
1093                     detStr.Data()));
1094       if (fStopOnError) return kFALSE;
1095     }
1096   }
1097
1098   delete runLoader;
1099   return kTRUE;
1100 }
1101
1102 //_____________________________________________________________________________
1103 Bool_t AliSimulation::ConvertRawFilesToDate(const char* dateFileName)
1104 {
1105 // convert raw data DDL files to a DATE file with the program "dateStream"
1106
1107   char* path = gSystem->Which(gSystem->Getenv("PATH"), "dateStream");
1108   if (!path) {
1109     AliError("the program dateStream was not found");
1110     if (fStopOnError) return kFALSE;
1111   } else {
1112     delete[] path;
1113   }
1114
1115   AliRunLoader* runLoader = LoadRun("READ");
1116   if (!runLoader) return kFALSE;
1117
1118   AliInfo(Form("converting raw data DDL files to DATE file %s", dateFileName));
1119   char command[256];
1120   sprintf(command, "dateStream -D -o %s -# %d -C",
1121           dateFileName, runLoader->GetNumberOfEvents());
1122   FILE* pipe = gSystem->OpenPipe(command, "w");
1123
1124   for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
1125     fprintf(pipe, "GDC\n");
1126     Float_t ldc = 0;
1127     Int_t prevLDC = -1;
1128
1129     // loop over detectors and DDLs
1130     for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
1131       for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls(iDet); iDDL++) {
1132
1133         Int_t ddlID = AliDAQ::DdlID(iDet,iDDL);
1134         Int_t ldcID = Int_t(ldc + 0.0001);
1135         ldc += AliDAQ::NumberOfLdcs(iDet) / AliDAQ::NumberOfDdls(iDet);
1136
1137         char rawFileName[256];
1138         sprintf(rawFileName, "raw%d/%s",
1139                 iEvent, AliDAQ::DdlFileName(iDet,iDDL));
1140
1141         // check existence and size of raw data file
1142         FILE* file = fopen(rawFileName, "rb");
1143         if (!file) continue;
1144         fseek(file, 0, SEEK_END);
1145         unsigned long size = ftell(file);
1146         fclose(file);
1147         if (!size) continue;
1148
1149         if (ldcID != prevLDC) {
1150           fprintf(pipe, " LDC Id %d\n", ldcID);
1151           prevLDC = ldcID;
1152         }
1153         fprintf(pipe, "  Equipment Id %d Payload %s\n", ddlID, rawFileName);
1154       }
1155     }
1156   }
1157
1158   Int_t result = gSystem->ClosePipe(pipe);
1159
1160   delete runLoader;
1161   return (result == 0);
1162 }
1163
1164 //_____________________________________________________________________________
1165 Bool_t AliSimulation::ConvertDateToRoot(const char* dateFileName,
1166                                         const char* rootFileName)
1167 {
1168 // convert a DATE file to a root file with the program "alimdc"
1169
1170   // ALIMDC setup
1171   const Int_t kDBSize = 1000000000;
1172   const Int_t kTagDBSize = 1000000000;
1173   const Bool_t kFilter = kFALSE;
1174   const Int_t kCompression = 1;
1175
1176   char* path = gSystem->Which(gSystem->Getenv("PATH"), "alimdc");
1177   if (!path) {
1178     AliError("the program alimdc was not found");
1179     if (fStopOnError) return kFALSE;
1180   } else {
1181     delete[] path;
1182   }
1183
1184   AliInfo(Form("converting DATE file %s to root file %s",
1185                dateFileName, rootFileName));
1186
1187   const char* rawDBFS[2] = { "/tmp/mdc1", "/tmp/mdc2" };
1188   const char* tagDBFS    = "/tmp/mdc1/tags";
1189   const char* runDBFS    = "/tmp/mdc1/meta";
1190
1191   // User defined file system locations
1192   if (gSystem->Getenv("ALIMDC_RAWDB1"))
1193     rawDBFS[0] = gSystem->Getenv("ALIMDC_RAWDB1");
1194   if (gSystem->Getenv("ALIMDC_RAWDB2"))
1195     rawDBFS[1] = gSystem->Getenv("ALIMDC_RAWDB2");
1196   if (gSystem->Getenv("ALIMDC_TAGDB"))
1197     tagDBFS = gSystem->Getenv("ALIMDC_TAGDB");
1198   if (gSystem->Getenv("ALIMDC_RUNDB"))
1199     runDBFS = gSystem->Getenv("ALIMDC_RUNDB");
1200
1201   gSystem->Exec(Form("rm -rf %s",rawDBFS[0]));
1202   gSystem->Exec(Form("rm -rf %s",rawDBFS[1]));
1203   gSystem->Exec(Form("rm -rf %s",tagDBFS));
1204   gSystem->Exec(Form("rm -rf %s",runDBFS));
1205
1206   gSystem->Exec(Form("mkdir %s",rawDBFS[0]));
1207   gSystem->Exec(Form("mkdir %s",rawDBFS[1]));
1208   gSystem->Exec(Form("mkdir %s",tagDBFS));
1209   gSystem->Exec(Form("mkdir %s",runDBFS));
1210
1211   Int_t result = gSystem->Exec(Form("alimdc %d %d %d %d %s",
1212                                     kDBSize, kTagDBSize, kFilter, kCompression, dateFileName));
1213   gSystem->Exec(Form("mv %s/*.root %s", rawDBFS[0], rootFileName));
1214
1215   gSystem->Exec(Form("rm -rf %s",rawDBFS[0]));
1216   gSystem->Exec(Form("rm -rf %s",rawDBFS[1]));
1217   gSystem->Exec(Form("rm -rf %s",tagDBFS));
1218   gSystem->Exec(Form("rm -rf %s",runDBFS));
1219
1220   return (result == 0);
1221 }
1222
1223
1224 //_____________________________________________________________________________
1225 AliRunLoader* AliSimulation::LoadRun(const char* mode) const
1226 {
1227 // delete existing run loaders, open a new one and load gAlice
1228
1229   while (AliRunLoader::GetRunLoader()) delete AliRunLoader::GetRunLoader();
1230   AliRunLoader* runLoader =
1231     AliRunLoader::Open(fGAliceFileName.Data(),
1232                        AliConfig::GetDefaultEventFolderName(), mode);
1233   if (!runLoader) {
1234     AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
1235     return NULL;
1236   }
1237   runLoader->LoadgAlice();
1238   gAlice = runLoader->GetAliRun();
1239   if (!gAlice) {
1240     AliError(Form("no gAlice object found in file %s",
1241                   fGAliceFileName.Data()));
1242     return NULL;
1243   }
1244   return runLoader;
1245 }
1246
1247 //_____________________________________________________________________________
1248 Int_t AliSimulation::GetNSignalPerBkgrd(Int_t nEvents) const
1249 {
1250 // get or calculate the number of signal events per background event
1251
1252   if (!fBkgrdFileNames) return 1;
1253   Int_t nBkgrdFiles = fBkgrdFileNames->GetEntriesFast();
1254   if (nBkgrdFiles == 0) return 1;
1255
1256   // get the number of signal events
1257   if (nEvents <= 0) {
1258     AliRunLoader* runLoader =
1259         AliRunLoader::Open(fGAliceFileName.Data(), "SIGNAL");
1260     if (!runLoader) return 1;
1261
1262     nEvents = runLoader->GetNumberOfEvents();
1263     delete runLoader;
1264   }
1265
1266   Int_t result = 0;
1267   for (Int_t iBkgrdFile = 0; iBkgrdFile < nBkgrdFiles; iBkgrdFile++) {
1268     // get the number of background events
1269     const char* fileName = ((TObjString*)
1270                             (fBkgrdFileNames->At(iBkgrdFile)))->GetName();
1271     AliRunLoader* runLoader =
1272       AliRunLoader::Open(fileName, "BKGRD");
1273     if (!runLoader) continue;
1274     Int_t nBkgrdEvents = runLoader->GetNumberOfEvents();
1275     delete runLoader;
1276
1277     // get or calculate the number of signal per background events
1278     Int_t nSignalPerBkgrd = fBkgrdFileNames->At(iBkgrdFile)->GetUniqueID();
1279     if (nSignalPerBkgrd <= 0) {
1280       nSignalPerBkgrd = (nEvents-1) / nBkgrdEvents + 1;
1281     } else if (result && (result != nSignalPerBkgrd)) {
1282       AliInfo(Form("the number of signal events per background event "
1283                    "will be changed from %d to %d for stream %d",
1284                    nSignalPerBkgrd, result, iBkgrdFile+1));
1285       nSignalPerBkgrd = result;
1286     }
1287
1288     if (!result) result = nSignalPerBkgrd;
1289     if (nSignalPerBkgrd * nBkgrdEvents < nEvents) {
1290       AliWarning(Form("not enough background events (%d) for %d signal events "
1291                       "using %d signal per background events for stream %d",
1292                       nBkgrdEvents, nEvents, nSignalPerBkgrd, iBkgrdFile+1));
1293     }
1294   }
1295
1296   return result;
1297 }
1298
1299 //_____________________________________________________________________________
1300 Bool_t AliSimulation::IsSelected(TString detName, TString& detectors) const
1301 {
1302 // check whether detName is contained in detectors
1303 // if yes, it is removed from detectors
1304
1305   // check if all detectors are selected
1306   if ((detectors.CompareTo("ALL") == 0) ||
1307       detectors.BeginsWith("ALL ") ||
1308       detectors.EndsWith(" ALL") ||
1309       detectors.Contains(" ALL ")) {
1310     detectors = "ALL";
1311     return kTRUE;
1312   }
1313
1314   // search for the given detector
1315   Bool_t result = kFALSE;
1316   if ((detectors.CompareTo(detName) == 0) ||
1317       detectors.BeginsWith(detName+" ") ||
1318       detectors.EndsWith(" "+detName) ||
1319       detectors.Contains(" "+detName+" ")) {
1320     detectors.ReplaceAll(detName, "");
1321     result = kTRUE;
1322   }
1323
1324   // clean up the detectors string
1325   while (detectors.Contains("  ")) detectors.ReplaceAll("  ", " ");
1326   while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
1327   while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
1328
1329   return result;
1330 }
1331
1332 Bool_t AliSimulation::ConvertRaw2SDigits(const char* rawDirectory, const char* esdFileName)
1333 {
1334 //
1335 // Steering routine  to convert raw data in directory rawDirectory/ to fake SDigits.
1336 // These can be used for embedding of MC tracks into RAW data using the standard
1337 // merging procedure.
1338 //
1339 // If an ESD file is given the reconstructed vertex is taken from it and stored in the event header.
1340 //
1341     if (!gAlice) {
1342         AliError("no gAlice object. Restart aliroot and try again.");
1343         return kFALSE;
1344     }
1345     if (gAlice->Modules()->GetEntries() > 0) {
1346         AliError("gAlice was already run. Restart aliroot and try again.");
1347         return kFALSE;
1348     }
1349
1350     AliInfo(Form("initializing gAlice with config file %s",fConfigFileName.Data()));
1351     StdoutToAliInfo(StderrToAliError(gAlice->Init(fConfigFileName.Data());););
1352 //
1353 //  Initialize CDB
1354     InitCDBStorage();
1355     AliCDBManager* man = AliCDBManager::Instance();
1356     man->SetRun(0); // Should this come from rawdata header ?
1357
1358     Int_t iDet;
1359     //
1360     // Get the runloader
1361     AliRunLoader* runLoader = gAlice->GetRunLoader();
1362     //
1363     // Open esd file if available
1364     TFile* esdFile = TFile::Open(esdFileName);
1365     Bool_t esdOK = (esdFile != 0);
1366     AliESD* esd = new AliESD;
1367     TTree* treeESD = 0;
1368     if (esdOK) {
1369         treeESD = (TTree*) esdFile->Get("esdTree");
1370         if (!treeESD) {
1371             AliWarning("No ESD tree found");
1372             esdOK = kFALSE;
1373         } else {
1374             treeESD->SetBranchAddress("ESD", &esd);
1375         }
1376     }
1377     //
1378     // Create the RawReader
1379     AliRawReaderFile* rawReader = new AliRawReaderFile(rawDirectory);
1380     //
1381     // Get list of detectors
1382     TObjArray* detArray = runLoader->GetAliRun()->Detectors();
1383     //
1384     // Get Header
1385     AliHeader* header = runLoader->GetHeader();
1386     //
1387     // Event loop
1388     Int_t nev = 0;
1389     while(kTRUE) {
1390         if (!(rawReader->NextEvent())) break;
1391         //
1392         // Detector loop
1393         for (iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
1394             AliModule* det = (AliModule*) detArray->At(iDet);
1395             AliInfo(Form("Calling Raw2SDigits for %s\n", det->GetName()));
1396             det->Raw2SDigits(rawReader);
1397             rawReader->Reset();
1398         } // detectors
1399
1400         //
1401         //  If ESD information available obtain reconstructed vertex and store in header.
1402         if (esdOK) {
1403             treeESD->GetEvent(nev);
1404             const AliESDVertex* esdVertex = esd->GetPrimaryVertex();
1405             Double_t position[3];
1406             esdVertex->GetXYZ(position);
1407             AliGenEventHeader* mcHeader = new  AliGenEventHeader("ESD");
1408             TArrayF mcV;
1409             mcV.Set(3);
1410             for (Int_t i = 0; i < 3; i++) mcV[i] = position[i];
1411             mcHeader->SetPrimaryVertex(mcV);
1412             header->Reset(0,nev);
1413             header->SetGenEventHeader(mcHeader);
1414             printf("***** Saved vertex %f %f %f \n", position[0], position[1], position[2]);
1415         }
1416         nev++;
1417 //
1418 //      Finish the event
1419         runLoader->TreeE()->Fill();
1420         runLoader->SetNextEvent();
1421     } // events
1422
1423     delete rawReader;
1424 //
1425 //  Finish the run
1426     runLoader->CdGAFile();
1427     runLoader->WriteHeader("OVERWRITE");
1428     runLoader->WriteRunLoader();
1429
1430     return kTRUE;
1431 }