X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=STEER%2FAliSimulation.cxx;h=18fe93a9720f7eeae282faa0c1243a9c294d8ccd;hb=30cd6a86dcdd3c1f195019d83b1ab55fa0e52281;hp=9a311e52a9666ef26f258b3da23672d5f22acb5f;hpb=e3b20d9a702ed6dce1697d17a56bad31a58dd471;p=u%2Fmrichter%2FAliRoot.git

diff --git a/STEER/AliSimulation.cxx b/STEER/AliSimulation.cxx
index 9a311e52a96..18fe93a9720 100644
--- a/STEER/AliSimulation.cxx
+++ b/STEER/AliSimulation.cxx
@@ -105,41 +105,49 @@
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
-#include <TVirtualMCApplication.h>
+#include <TCint.h>
+#include <TFile.h>
+#include <TGeoGlobalMagField.h>
 #include <TGeoManager.h>
 #include <TObjString.h>
+#include <TROOT.h>
 #include <TSystem.h>
-#include <TFile.h>
+#include <TVirtualMC.h>
+#include <TVirtualMCApplication.h>
 
-#include "AliCodeTimer.h"
-#include "AliCDBStorage.h"
+#include "AliAlignObj.h"
 #include "AliCDBEntry.h"
 #include "AliCDBManager.h"
-#include "AliGeomManager.h"
-#include "AliAlignObj.h"
+#include "AliCDBStorage.h"
+#include "AliCTPRawData.h"
+#include "AliCentralTrigger.h"
 #include "AliCentralTrigger.h"
+#include "AliCodeTimer.h"
 #include "AliDAQ.h"
 #include "AliDigitizer.h"
+#include "AliESD.h"
+#include "AliGRPObject.h"
+#include "AliGenEventHeader.h"
 #include "AliGenerator.h"
+#include "AliGeomManager.h"
+#include "AliHLTSimulation.h"
+#include "AliHeader.h"
+#include "AliLego.h"
+#include "AliLegoGenerator.h"
 #include "AliLog.h"
+#include "AliMC.h"
+#include "AliMagF.h"
 #include "AliModule.h"
+#include "AliPDG.h"
+#include "AliRawReaderDate.h"
+#include "AliRawReaderFile.h"
+#include "AliRawReaderRoot.h"
 #include "AliRun.h"
 #include "AliRunDigitizer.h"
 #include "AliRunLoader.h"
 #include "AliSimulation.h"
-#include "AliVertexGenFile.h"
-#include "AliCentralTrigger.h"
-#include "AliCTPRawData.h"
-#include "AliRawReaderFile.h"
-#include "AliRawReaderRoot.h"
-#include "AliRawReaderDate.h"
-#include "AliESD.h"
-#include "AliHeader.h"
-#include "AliGenEventHeader.h"
-#include "AliMC.h"
-#include "AliHLTSimulation.h"
-#include "AliQADataMakerSteer.h"
 #include "AliSysInfo.h"
+#include "AliVertexGenFile.h"
 
 ClassImp(AliSimulation)
 
@@ -164,7 +172,6 @@ AliSimulation::AliSimulation(const char* configFileName,
   fDeleteIntermediateFiles(kFALSE),
   fWriteSelRawData(kFALSE),
   fStopOnError(kFALSE),
-
   fNEvents(1),
   fConfigFileName(configFileName),
   fGAliceFileName("galice.root"),
@@ -181,90 +188,24 @@ AliSimulation::AliSimulation(const char* configFileName,
   fInitRunNumberCalled(kFALSE),
   fSetRunNumberFromDataCalled(kFALSE),
   fEmbeddingFlag(kFALSE),
+  fLego(NULL),
   fQADetectors("ALL"),                  
   fQATasks("ALL"),	
+  fQASteer(NULL), 
   fRunQA(kTRUE), 
-  fRunHLT("default")
+  fEventSpecie(AliRecoParam::kDefault),
+  fRunHLT("default"),
+  fWriteGRPEntry(kTRUE)
 {
 // create simulation object with default parameters
   fgInstance = this;
   SetGAliceFile("galice.root");
   
 // for QA
-   for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) 
-	fQACycles[iDet] = 999999;
-}
-
-//_____________________________________________________________________________
-AliSimulation::AliSimulation(const AliSimulation& sim) :
-  TNamed(sim),
-
-  fRunGeneration(sim.fRunGeneration),
-  fRunSimulation(sim.fRunSimulation),
-  fLoadAlignFromCDB(sim.fLoadAlignFromCDB),
-  fLoadAlObjsListOfDets(sim.fLoadAlObjsListOfDets),
-  fMakeSDigits(sim.fMakeSDigits),
-  fMakeDigits(sim.fMakeDigits),
-  fMakeTrigger(sim.fMakeTrigger),
-  fMakeDigitsFromHits(sim.fMakeDigitsFromHits),
-  fWriteRawData(sim.fWriteRawData),
-  fRawDataFileName(""),
-  fDeleteIntermediateFiles(kFALSE),
-  fWriteSelRawData(kFALSE),
-  fStopOnError(sim.fStopOnError),
-
-  fNEvents(sim.fNEvents),
-  fConfigFileName(sim.fConfigFileName),
-  fGAliceFileName(sim.fGAliceFileName),
-  fEventsPerFile(),
-  fBkgrdFileNames(NULL),
-  fAlignObjArray(NULL),
-  fUseBkgrdVertex(sim.fUseBkgrdVertex),
-  fRegionOfInterest(sim.fRegionOfInterest),
-  fCDBUri(sim.fCDBUri),
-  fSpecCDBUri(),
-  fRun(-1),
-  fSeed(0),
-  fInitCDBCalled(sim.fInitCDBCalled),
-  fInitRunNumberCalled(sim.fInitRunNumberCalled),
-  fSetRunNumberFromDataCalled(sim.fSetRunNumberFromDataCalled),
-  fEmbeddingFlag(sim.fEmbeddingFlag),
-  fQADetectors(sim.fQADetectors),                  
-  fQATasks(sim.fQATasks),	
-  fRunQA(sim.fRunQA), 
-  fRunHLT(sim.fRunHLT)
-{
-// copy constructor
-
-  for (Int_t i = 0; i < sim.fEventsPerFile.GetEntriesFast(); i++) {
-    if (!sim.fEventsPerFile[i]) continue;
-    fEventsPerFile.Add(sim.fEventsPerFile[i]->Clone());
-  }
-
-  fBkgrdFileNames = new TObjArray;
-  for (Int_t i = 0; i < sim.fBkgrdFileNames->GetEntriesFast(); i++) {
-    if (!sim.fBkgrdFileNames->At(i)) continue;
-    fBkgrdFileNames->Add(sim.fBkgrdFileNames->At(i)->Clone());
-  }
-
-  for (Int_t i = 0; i < sim.fSpecCDBUri.GetEntriesFast(); i++) {
-    if (sim.fSpecCDBUri[i]) fSpecCDBUri.Add(sim.fSpecCDBUri[i]->Clone());
-  }
-  fgInstance = this;
-
-// for QA
-   for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) 
-	fQACycles[iDet] = sim.fQACycles[iDet];
-}
-
-//_____________________________________________________________________________
-AliSimulation& AliSimulation::operator = (const AliSimulation& sim)
-{
-// assignment operator
-
-  this->~AliSimulation();
-  new(this) AliSimulation(sim);
-  return *this;
+	fQASteer = new AliQADataMakerSteer("sim") ; 
+	fQASteer->SetActiveDetectors(fQADetectors) ; 
+	fQATasks = Form("%d %d %d", AliQA::kHITS, AliQA::kSDIGITS, AliQA::kDIGITS) ; 
+	fQASteer->SetTasks(fQATasks) ; 	
 }
 
 //_____________________________________________________________________________
@@ -284,6 +225,8 @@ AliSimulation::~AliSimulation()
   fSpecCDBUri.Delete();
   if (fgInstance==this) fgInstance = 0;
 
+	delete fQASteer ; 
+	
   AliCodeTimer::Instance()->Print();
 }
 
@@ -443,7 +386,7 @@ Bool_t AliSimulation::SetRunNumberFromData()
     AliRunLoader* runLoader = LoadRun("READ");
     if (!runLoader) return kFALSE;
     else {
-    	runData = runLoader->GetAliRun()->GetHeader()->GetRun();
+    	runData = runLoader->GetHeader()->GetRun();
 	delete runLoader;
     }
   
@@ -718,9 +661,9 @@ Bool_t AliSimulation::Run(Int_t nEvents)
   }
 
   
-  
-  // run HLT simulation
-  if (!fRunHLT.IsNull()) {
+  // run HLT simulation on simulated digit data if raw data is not
+  // simulated, otherwise its called as part of WriteRawData
+  if (!fRunHLT.IsNull() && fWriteRawData.IsNull()) {
     if (!RunHLT()) {
       if (fStopOnError) return kFALSE;
     }
@@ -740,6 +683,144 @@ Bool_t AliSimulation::Run(Int_t nEvents)
   return kTRUE;
 }
 
+//_______________________________________________________________________
+Bool_t AliSimulation::RunLego(const char *setup, Int_t nc1, Float_t c1min,
+		     Float_t c1max,Int_t nc2,Float_t c2min,Float_t c2max,
+		     Float_t rmin,Float_t rmax,Float_t zmax, AliLegoGenerator* gener, Int_t nev)
+{
+  //
+  // Generates lego plots of:
+  //    - radiation length map phi vs theta
+  //    - radiation length map phi vs eta
+  //    - interaction length map
+  //    - g/cm2 length map
+  //
+  //  ntheta    bins in theta, eta
+  //  themin    minimum angle in theta (degrees)
+  //  themax    maximum angle in theta (degrees)
+  //  nphi      bins in phi
+  //  phimin    minimum angle in phi (degrees)
+  //  phimax    maximum angle in phi (degrees)
+  //  rmin      minimum radius
+  //  rmax      maximum radius
+  //  
+  //
+  //  The number of events generated = ntheta*nphi
+  //  run input parameters in macro setup (default="Config.C")
+  //
+  //  Use macro "lego.C" to visualize the 3 lego plots in spherical coordinates
+  //Begin_Html
+  /*
+    <img src="picts/AliRunLego1.gif">
+  */
+  //End_Html
+  //Begin_Html
+  /*
+    <img src="picts/AliRunLego2.gif">
+  */
+  //End_Html
+  //Begin_Html
+  /*
+    <img src="picts/AliRunLego3.gif">
+  */
+  //End_Html
+  //
+
+// run the generation and simulation
+
+  AliCodeTimerAuto("")
+
+  // initialize CDB storage and run number from external environment
+  // (either CDB manager or AliSimulation setters)
+  InitCDB();
+  InitRunNumber();
+  SetCDBLock();
+  
+  if (!gAlice) {
+    AliError("no gAlice object. Restart aliroot and try again.");
+    return kFALSE;
+  }
+  if (gAlice->Modules()->GetEntries() > 0) {
+    AliError("gAlice was already run. Restart aliroot and try again.");
+    return kFALSE;
+  }
+
+  AliInfo(Form("initializing gAlice with config file %s",
+          fConfigFileName.Data()));
+
+  // Number of events 
+    if (nev == -1) nev  = nc1 * nc2;
+    
+  // check if initialisation has been done
+  // If runloader has been initialized, set the number of events per file to nc1 * nc2
+    
+  // Set new generator
+  if (!gener) gener  = new AliLegoGenerator();
+  //
+  // Configure Generator
+
+  gener->SetRadiusRange(rmin, rmax);
+  gener->SetZMax(zmax);
+  gener->SetCoor1Range(nc1, c1min, c1max);
+  gener->SetCoor2Range(nc2, c2min, c2max);
+  
+  
+  //Create Lego object  
+  fLego = new AliLego("lego",gener);
+
+  //__________________________________________________________________________
+
+  gAlice->Announce();
+
+  gROOT->LoadMacro(setup);
+  gInterpreter->ProcessLine(gAlice->GetConfigFunction());
+
+  if(AliCDBManager::Instance()->GetRun() >= 0) { 
+    SetRunNumber(AliCDBManager::Instance()->GetRun());
+  } else {
+    AliWarning("Run number not initialized!!");
+  }
+
+  AliRunLoader::Instance()->CdGAFile();
+  
+  AliPDG::AddParticlesToPdgDataBase();  
+  
+  gAlice->GetMCApp()->Init();
+  
+  gMC->SetMagField(TGeoGlobalMagField::Instance()->GetField());
+
+  
+  //Must be here because some MCs (G4) adds detectors here and not in Config.C
+  gAlice->InitLoaders();
+  AliRunLoader::Instance()->MakeTree("E");
+  
+  //
+  // Save stuff at the beginning of the file to avoid file corruption
+  AliRunLoader::Instance()->CdGAFile();
+  gAlice->Write();
+
+  //Save current generator
+  AliGenerator *gen=gAlice->GetMCApp()->Generator();
+  gAlice->GetMCApp()->ResetGenerator(gener);
+  //Prepare MC for Lego Run
+  gMC->InitLego();
+  
+  //Run Lego Object
+  
+  
+  AliRunLoader::Instance()->SetNumberOfEventsPerFile(nev);
+  gMC->ProcessRun(nev);
+  
+  // End of this run, close files
+  FinishRun();
+  // Restore current generator
+  gAlice->GetMCApp()->ResetGenerator(gen);
+  // Delete Lego Object
+  delete fLego;
+
+  return kTRUE;
+}
+
 //_____________________________________________________________________________
 Bool_t AliSimulation::RunTrigger(const char* config, const char* detectors)
 {
@@ -765,7 +846,7 @@ Bool_t AliSimulation::RunTrigger(const char* config, const char* detectors)
    TString trconfiguration = config;
 
    if (trconfiguration.IsNull()) {
-     if (gAlice->GetTriggerDescriptor() != "") {
+     if (strcmp(gAlice->GetTriggerDescriptor(),"")) {
        trconfiguration = gAlice->GetTriggerDescriptor();
      }
      else
@@ -827,15 +908,48 @@ Bool_t AliSimulation::RunSimulation(Int_t nEvents)
 
   AliInfo(Form("initializing gAlice with config file %s",
           fConfigFileName.Data()));
-  StdoutToAliInfo(StderrToAliError(
-    gAlice->Init(fConfigFileName.Data());
-  ););
+
+  //
+  // Initialize ALICE Simulation run
+  //
+
+  gAlice->Announce();
+
+  gROOT->LoadMacro(fConfigFileName.Data());
+  gInterpreter->ProcessLine(gAlice->GetConfigFunction());
+
+  if(AliCDBManager::Instance()->GetRun() >= 0) { 
+    AliRunLoader::Instance()->SetRunNumber(AliCDBManager::Instance()->GetRun());
+  } else {
+  	AliWarning("Run number not initialized!!");
+  }
+  
+   AliRunLoader::Instance()->CdGAFile();
+    
+   AliPDG::AddParticlesToPdgDataBase();  
+
+   gAlice->GetMCApp()->Init();
+
+   gMC->SetMagField(TGeoGlobalMagField::Instance()->GetField());
+   
+   //Must be here because some MCs (G4) adds detectors here and not in Config.C
+   gAlice->InitLoaders();
+   AliRunLoader::Instance()->MakeTree("E");
+   AliRunLoader::Instance()->LoadKinematics("RECREATE");
+   AliRunLoader::Instance()->LoadTrackRefs("RECREATE");
+   AliRunLoader::Instance()->LoadHits("all","RECREATE");
+   //
+   // Save stuff at the beginning of the file to avoid file corruption
+   AliRunLoader::Instance()->CdGAFile();
+   gAlice->Write();
+   gAlice->SetEventNrInRun(-1); //important - we start Begin event from increasing current number in run
+  //___________________________________________________________________________________________
   
   // Get the trigger descriptor string
   // Either from AliSimulation or from
   // gAlice
   if (fMakeTrigger.IsNull()) {
-    if (gAlice->GetTriggerDescriptor() != "")
+    if (strcmp(gAlice->GetTriggerDescriptor(),""))
       fMakeTrigger = gAlice->GetTriggerDescriptor();
   }
   else
@@ -844,7 +958,7 @@ Bool_t AliSimulation::RunSimulation(Int_t nEvents)
   // Set run number in CDBManager
   AliInfo(Form("Run number: %d",AliCDBManager::Instance()->GetRun()));
 
-  AliRunLoader* runLoader = gAlice->GetRunLoader();
+  AliRunLoader* runLoader = AliRunLoader::Instance();
   if (!runLoader) {
              AliError(Form("gAlice has no run loader object. "
         		     "Check your config file: %s", fConfigFileName.Data()));
@@ -871,7 +985,7 @@ Bool_t AliSimulation::RunSimulation(Int_t nEvents)
   MisalignGeometry(runLoader);
 #endif
 
-//   AliRunLoader* runLoader = gAlice->GetRunLoader();
+//   AliRunLoader* runLoader = AliRunLoader::Instance();
 //   if (!runLoader) {
 //     AliError(Form("gAlice has no run loader object. "
 //                   "Check your config file: %s", fConfigFileName.Data()));
@@ -879,11 +993,16 @@ Bool_t AliSimulation::RunSimulation(Int_t nEvents)
 //   }
 //   SetGAliceFile(runLoader->GetFileName());
 
-  if (!gAlice->Generator()) {
+  if (!gAlice->GetMCApp()->Generator()) {
     AliError(Form("gAlice has no generator object. "
                   "Check your config file: %s", fConfigFileName.Data()));
     return kFALSE;
   }
+
+  // Write GRP entry corresponding to the setting found in Cofig.C
+  if (fWriteGRPEntry)
+    WriteGRPEntry();
+
   if (nEvents <= 0) nEvents = fNEvents;
 
   // get vertex from background file in case of merging
@@ -896,11 +1015,11 @@ Bool_t AliSimulation::RunSimulation(Int_t nEvents)
                  "file %s with nSignalPerBackground = %d", 
                  fileName, signalPerBkgrd));
     AliVertexGenFile* vtxGen = new AliVertexGenFile(fileName, signalPerBkgrd);
-    gAlice->Generator()->SetVertexGenerator(vtxGen);
+    gAlice->GetMCApp()->Generator()->SetVertexGenerator(vtxGen);
   }
 
   if (!fRunSimulation) {
-    gAlice->Generator()->SetTrackingFlag(0);
+    gAlice->GetMCApp()->Generator()->SetTrackingFlag(0);
   }
 
   // set the number of events per file for given detectors and data types
@@ -932,9 +1051,15 @@ Bool_t AliSimulation::RunSimulation(Int_t nEvents)
 
   AliInfo("running gAlice");
   AliSysInfo::AddStamp("Start_simulation");
-  StdoutToAliInfo(StderrToAliError(
-    gAlice->Run(nEvents);
-  ););
+
+  // Create the Root Tree with one branch per detector
+  //Hits moved to begin event -> now we are crating separate tree for each event
+
+  gMC->ProcessRun(nEvents);
+
+  // End of this run, close files
+  if(nEvents>0) FinishRun();
+
   AliSysInfo::AddStamp("Stop_simulation");
   delete runLoader;
 
@@ -994,8 +1119,8 @@ Bool_t AliSimulation::RunDigitization(const char* detectors,
   if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
   SetCDBLock();
   
-  while (AliRunLoader::GetRunLoader()) delete AliRunLoader::GetRunLoader();
-  if (gAlice) delete gAlice;
+  delete AliRunLoader::Instance();
+  delete gAlice;
   gAlice = NULL;
 
   Int_t nStreams = 1;
@@ -1080,10 +1205,6 @@ Bool_t AliSimulation::RunHitsDigitization(const char* detectors)
     if (fStopOnError) return kFALSE;
   }
 
-  delete runLoader;
-  //PH Temporary fix to avoid interference with the PHOS loder/getter
-  //PH The problem has to be solved in more general way 09/06/05
-
   return kTRUE;
 }
 
@@ -1105,11 +1226,20 @@ Bool_t AliSimulation::WriteRawData(const char* detectors,
 // accoring to the trigger cluster.
 
   AliCodeTimerAuto("")
-
-  if (!WriteRawFiles(detectors)) {
+  
+  TString detStr = detectors;
+  if (!WriteRawFiles(detStr.Data())) {
     if (fStopOnError) return kFALSE;
   }
 
+  // run HLT simulation on simulated DDL raw files
+  // and produce HLT ddl raw files to be included in date/root file
+  if (IsSelected("HLT", detStr) && !fRunHLT.IsNull()) {
+    if (!RunHLT()) {
+      if (fStopOnError) return kFALSE;
+    }
+  }
+
   TString dateFileName(fileName);
   if (!dateFileName.IsNull()) {
     Bool_t rootOutput = dateFileName.EndsWith(".root");
@@ -1178,7 +1308,15 @@ Bool_t AliSimulation::WriteRawFiles(const char* detectors)
       if (fStopOnError) return kFALSE; else continue;
     }
 
+    ofstream runNbFile(Form("run%u",runLoader->GetHeader()->GetRun()));
+    runNbFile.close();
+
     TString detStr = detectors;
+    if (IsSelected("HLT", detStr)) {
+      // Do nothing. "HLT" will be removed from detStr and HLT raw
+      // data files are generated in RunHLT.
+    }
+
     TObjArray* detArray = runLoader->GetAliRun()->Detectors();
     for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
       AliModule* det = (AliModule*) detArray->At(iDet);
@@ -1237,25 +1375,36 @@ Bool_t AliSimulation::ConvertRawFilesToDate(const char* dateFileName,
 	  dateFileName, runLoader->GetNumberOfEvents(),runLoader->GetHeader()->GetRun());
   FILE* pipe = gSystem->OpenPipe(command, "w");
 
+  if (!pipe) {
+    AliError(Form("Cannot execute command: %s",command));
+    return kFALSE;
+  }
+
   Int_t selEvents = 0;
   for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
-    fprintf(pipe, "GDC\n");
-    Float_t ldc = 0;
-    Int_t prevLDC = -1;
 
-    if (selrawdata) {
+    UInt_t detectorPattern = 0;
+    runLoader->GetEvent(iEvent);
+    if (!runLoader->LoadTrigger()) {
+      AliCentralTrigger *aCTP = runLoader->GetTrigger();
+      detectorPattern = aCTP->GetClusterMask();
       // Check if the event was triggered by CTP
-      runLoader->GetEvent(iEvent);
-      if (!runLoader->LoadTrigger()) {
-	AliCentralTrigger *aCTP = runLoader->GetTrigger();
+      if (selrawdata) {
 	if (aCTP->GetClassMask()) selEvents++;
       }
-      else {
+    }
+    else {
+      AliWarning("No trigger can be loaded! Some fields in the event header will be empty !");
+      if (selrawdata) {
 	AliWarning("No trigger can be loaded! Writing of selected raw data is abandoned !");
 	selrawdata = kFALSE;
       }
     }
 
+    fprintf(pipe, "GDC DetectorPattern %u\n", detectorPattern);
+    Float_t ldc = 0;
+    Int_t prevLDC = -1;
+
     // loop over detectors and DDLs
     for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
       for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls(iDet); iDDL++) {
@@ -1301,16 +1450,18 @@ Bool_t AliSimulation::ConvertRawFilesToDate(const char* dateFileName,
   for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
 
     // Get the trigger decision and cluster
+    UInt_t detectorPattern = 0;
     TString detClust;
     runLoader->GetEvent(iEvent);
     if (!runLoader->LoadTrigger()) {
       AliCentralTrigger *aCTP = runLoader->GetTrigger();
       if (aCTP->GetClassMask() == 0) continue;
-      detClust = aCTP->GetTriggeredDetectors();
+      detectorPattern = aCTP->GetClusterMask();
+      detClust = AliDAQ::ListOfTriggeredDetectors(detectorPattern);
       AliInfo(Form("List of detectors to be read out: %s",detClust.Data()));
     }
 
-    fprintf(pipe2, "GDC\n");
+    fprintf(pipe2, "GDC DetectorPattern %u\n", detectorPattern);
     Float_t ldc = 0;
     Int_t prevLDC = -1;
 
@@ -1412,7 +1563,7 @@ AliRunLoader* AliSimulation::LoadRun(const char* mode) const
 {
 // delete existing run loaders, open a new one and load gAlice
 
-  while (AliRunLoader::GetRunLoader()) delete AliRunLoader::GetRunLoader();
+  delete AliRunLoader::Instance();
   AliRunLoader* runLoader = 
     AliRunLoader::Open(fGAliceFileName.Data(), 
 		       AliConfig::GetDefaultEventFolderName(), mode);
@@ -1526,17 +1677,46 @@ Bool_t AliSimulation::ConvertRaw2SDigits(const char* rawDirectory, const char* e
 //
 // If an ESD file is given the reconstructed vertex is taken from it and stored in the event header.
 //
-    if (!gAlice) {
-	AliError("no gAlice object. Restart aliroot and try again.");
-	return kFALSE;
-    }
-    if (gAlice->Modules()->GetEntries() > 0) {
-	AliError("gAlice was already run. Restart aliroot and try again.");
-	return kFALSE;
-    }
+  if (!gAlice) {
+    AliError("no gAlice object. Restart aliroot and try again.");
+    return kFALSE;
+  }
+  if (gAlice->Modules()->GetEntries() > 0) {
+    AliError("gAlice was already run. Restart aliroot and try again.");
+    return kFALSE;
+  }
+  
+  AliInfo(Form("initializing gAlice with config file %s",fConfigFileName.Data()));
+  
+  gAlice->Announce();
+  
+  gROOT->LoadMacro(fConfigFileName.Data());
+  gInterpreter->ProcessLine(gAlice->GetConfigFunction());
+  
+  if(AliCDBManager::Instance()->GetRun() >= 0) { 
+  	SetRunNumber(AliCDBManager::Instance()->GetRun());
+  } else {
+  	AliWarning("Run number not initialized!!");
+  }
+  
+   AliRunLoader::Instance()->CdGAFile();
     
-    AliInfo(Form("initializing gAlice with config file %s",fConfigFileName.Data()));
-    StdoutToAliInfo(StderrToAliError(gAlice->Init(fConfigFileName.Data());););
+   AliPDG::AddParticlesToPdgDataBase();  
+
+   gAlice->GetMCApp()->Init();
+
+   gMC->SetMagField(TGeoGlobalMagField::Instance()->GetField());
+   
+   //Must be here because some MCs (G4) adds detectors here and not in Config.C
+   gAlice->InitLoaders();
+   AliRunLoader::Instance()->MakeTree("E");
+   AliRunLoader::Instance()->LoadKinematics("RECREATE");
+   AliRunLoader::Instance()->LoadTrackRefs("RECREATE");
+   AliRunLoader::Instance()->LoadHits("all","RECREATE");
+   //
+   // Save stuff at the beginning of the file to avoid file corruption
+   AliRunLoader::Instance()->CdGAFile();
+   gAlice->Write();
 //
 //  Initialize CDB     
     InitCDB();
@@ -1546,7 +1726,7 @@ Bool_t AliSimulation::ConvertRaw2SDigits(const char* rawDirectory, const char* e
     Int_t iDet;
     //
     // Get the runloader
-    AliRunLoader* runLoader = gAlice->GetRunLoader();
+    AliRunLoader* runLoader = AliRunLoader::Instance();
     //
     // Open esd file if available
     TFile* esdFile = TFile::Open(esdFileName);
@@ -1572,7 +1752,6 @@ Bool_t AliSimulation::ConvertRaw2SDigits(const char* rawDirectory, const char* e
       rawReader = new AliRawReaderRoot(fileName);
     } else if (!fileName.IsNull()) {
       rawReader = new AliRawReaderDate(fileName);
-      rawReader->SelectEvents(7);
     }
 //     if (!fEquipIdMap.IsNull() && fRawReader)
 //       fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
@@ -1634,6 +1813,40 @@ Bool_t AliSimulation::ConvertRaw2SDigits(const char* rawDirectory, const char* e
     return kTRUE;
 }
 
+//_____________________________________________________________________________
+void AliSimulation::FinishRun()
+{
+  //
+  // Called at the end of the run.
+  //
+
+  if(IsLegoRun()) 
+   {
+    AliDebug(1, "Finish Lego");
+    AliRunLoader::Instance()->CdGAFile();
+    fLego->FinishRun();
+   }
+  
+  // Clean detector information
+  TIter next(gAlice->Modules());
+  AliModule *detector;
+  while((detector = dynamic_cast<AliModule*>(next()))) {
+    AliDebug(2, Form("%s->FinishRun()", detector->GetName()));
+    detector->FinishRun();
+  }
+  
+  AliDebug(1, "AliRunLoader::Instance()->WriteHeader(OVERWRITE)");
+  AliRunLoader::Instance()->WriteHeader("OVERWRITE");
+
+  // Write AliRun info and all detectors parameters
+  AliRunLoader::Instance()->CdGAFile();
+  gAlice->Write(0,TObject::kOverwrite);//write AliRun
+  AliRunLoader::Instance()->Write(0,TObject::kOverwrite);//write RunLoader itself
+  
+  if(gAlice->GetMCApp()) gAlice->GetMCApp()->FinishRun();  
+  AliRunLoader::Instance()->Synchronize();
+}
+
 //_____________________________________________________________________________
 Int_t AliSimulation::GetDetIndex(const char* detector)
 {
@@ -1655,8 +1868,8 @@ Bool_t AliSimulation::RunHLT()
   // AliSimulation::SetRunHLT can be used to set the options for HLT simulation
   // The default simulation depends on the HLT component libraries and their
   // corresponding agents which define components and chains to run. See
-  // http://web.ift.uib.no/~kjeks/doc/alice-hlt/
-  // http://web.ift.uib.no/~kjeks/doc/alice-hlt/classAliHLTModuleAgent.html
+  // http://web.ift.uib.no/~kjeks/doc/alice-hlt-current/
+  // http://web.ift.uib.no/~kjeks/doc/alice-hlt-current/classAliHLTModuleAgent.html
   //
   // The libraries to be loaded can be specified as an option.
   // <pre>
@@ -1672,8 +1885,11 @@ Bool_t AliSimulation::RunHLT()
   //     disable redirection of log messages to AliLog class
   // \li config=<i>macro</i>
   //     configuration macro
-  // \li localrec=<i>configuration</i>
+  // \li chains=<i>configuration</i>
   //     comma separated list of configurations to be run during simulation
+  // \li rawfile=<i>file</i>
+  //     source for the RawReader to be created, the default is <i>./</i> if
+  //     raw data is simulated
 
   int iResult=0;
   AliRunLoader* pRunLoader = LoadRun("READ");
@@ -1702,12 +1918,14 @@ Bool_t AliSimulation::RunHLT()
   typedef void (*CompileInfo)( char*& date, char*& time);
   CompileInfo fctInfo=(CompileInfo)gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, "CompileInfo");
   if (fctInfo) {
-    char* date="";
-    char* time="";
-    (*fctInfo)(date, time);
-    if (!date) date="unknown";
-    if (!time) time="unknown";
+    Char_t* date=0;
+    Char_t* time=0;
+    (*fctInfo)(date,time);
+    if (!date) {date=new Char_t[8]; strcpy(date,"unknown");}
+    if (!time) {time=new Char_t[8]; strcpy(time,"unknown");}
     AliInfo(Form("%s build on %s (%s)", ALIHLTSIMULATION_LIBRARY, date, time));
+    delete date;
+    delete time;
   } else {
     AliInfo(Form("no build info available for %s", ALIHLTSIMULATION_LIBRARY));
   }
@@ -1723,11 +1941,21 @@ Bool_t AliSimulation::RunHLT()
   // init the HLT simulation
   TString options;
   if (fRunHLT.CompareTo("default")!=0) options=fRunHLT;
-  if (!IsSelected("HLT", fWriteRawData)) {
+  TString detStr = fWriteRawData;
+  if (!IsSelected("HLT", detStr)) {
     options+=" writerawfiles=";
   } else {
     options+=" writerawfiles=HLT";
   }
+
+  if (!detStr.IsNull() && !options.Contains("rawfile=")) {
+    // as a matter of fact, HLT will run reconstruction and needs the RawReader
+    // in order to get detector data. By default, RawReaderFile is used to read
+    // the already simulated ddl files. Date and Root files from the raw data
+    // are generated after the HLT simulation.
+    options+=" rawfile=./";
+  }
+
   AliHLTSimulationInit_t fctInit=(AliHLTSimulationInit_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_INIT));
   if (fctInit==NULL || (iResult=(fctInit(pHLT, pRunLoader, options.Data())))<0) {
     AliError(Form("can not init HLT simulation: error %d (init %p)", iResult, fctInit));
@@ -1753,21 +1981,14 @@ Bool_t AliSimulation::RunHLT()
 Bool_t AliSimulation::RunQA()
 {
 	// run the QA on summable hits, digits or digits
-
-	AliQADataMakerSteer qas ; 
-    qas.SetRunLoader(gAlice->GetRunLoader()) ;
+	
+  if(!gAlice) return kFALSE;
+	fQASteer->SetRunLoader(AliRunLoader::Instance()) ;
 
 	TString detectorsw("") ;  
 	Bool_t rv = kTRUE ; 
-	if (fQATasks.Contains(Form("%d", AliQA::kHITS))) 
-		detectorsw =  qas.Run(fQADetectors.Data(), AliQA::kHITS) ; 
-//	qas.Reset() ; 
-	if (fQATasks.Contains(Form("%d", AliQA::kSDIGITS))) 
-		detectorsw += qas.Run(fQADetectors.Data(), AliQA::kSDIGITS) ;   
-//	qas.Reset() ; 
-	if (fQATasks.Contains(Form("%d", AliQA::kDIGITS))) 
-		detectorsw += qas.Run(fQADetectors.Data(), AliQA::kDIGITS) ; 	
-
+  fQASteer->SetEventSpecie(fEventSpecie) ;
+	detectorsw = fQASteer->Run(fQADetectors.Data()) ; 
 	if ( detectorsw.IsNull() ) 
 		rv = kFALSE ; 
 	return rv ; 
@@ -1789,7 +2010,7 @@ Bool_t AliSimulation::SetRunQA(TString detAndAction)
 	fQADetectors = detAndAction(0, colon) ; 
 	if (fQADetectors.Contains("ALL") )
 		fQADetectors = Form("%s %s", fMakeDigits.Data(), fMakeDigitsFromHits.Data()) ; 
-	fQATasks   = detAndAction(colon+1, detAndAction.Sizeof() ) ; 
+		fQATasks   = detAndAction(colon+1, detAndAction.Sizeof() ) ; 
 	if (fQATasks.Contains("ALL") ) {
 		fQATasks = Form("%d %d %d", AliQA::kHITS, AliQA::kSDIGITS, AliQA::kDIGITS) ; 
 	} else {
@@ -1814,6 +2035,11 @@ Bool_t AliSimulation::SetRunQA(TString detAndAction)
     tempo.ReplaceAll(Form("%d", AliQA::kDIGITS), AliQA::GetTaskName(AliQA::kDIGITS)) ; 	
 	AliInfo( Form("QA will be done on \"%s\" for \"%s\"\n", fQADetectors.Data(), tempo.Data()) ) ;  
 	fRunQA = kTRUE ;
+	fQASteer->SetActiveDetectors(fQADetectors) ; 
+	fQASteer->SetTasks(fQATasks) ; 
+  for (Int_t det = 0 ; det < AliQA::kNDET ; det++) 
+    fQASteer->SetWriteExpert(AliQA::DETECTORINDEX_t(det)) ;
+  
 	return kTRUE; 
 } 
 
@@ -1856,4 +2082,113 @@ void AliSimulation::ProcessEnvironmentVars()
     AliInfo(Form("Run number = %d", fRun)); 
 }
 
+//---------------------------------------------------------------------
+void AliSimulation::WriteGRPEntry()
+{
+  // Get the necessary information from galice (generator, trigger etc) and
+  // write a GRP entry corresponding to the settings in the Config.C used
+  // note that Hall probes and Cavern and Surface Atmos pressures are not simulated.
+
+
+  AliInfo("Writing global run parameters entry into the OCDB");
+
+  AliGRPObject* grpObj = new AliGRPObject();
+
+  grpObj->SetRunType("PHYSICS");
+  grpObj->SetTimeStart(0);
+  grpObj->SetTimeEnd(9999);
+
+  const AliGenerator *gen = gAlice->GetMCApp()->Generator();
+  if (gen) {
+    grpObj->SetBeamEnergy(gen->GetEnergyCMS());
+    TString projectile;
+    Int_t a,z;
+    gen->GetProjectile(projectile,a,z);
+    TString target;
+    gen->GetTarget(target,a,z);
+    TString beamType = projectile + "-" + target;
+    beamType.ReplaceAll(" ","");
+    if (!beamType.CompareTo("-")) {
+      grpObj->SetBeamType("UNKNOWN");
+    }
+    else {
+      grpObj->SetBeamType(beamType);
+      // Heavy ion run, the event specie is set to kHighMult
+      fEventSpecie = AliRecoParam::kHighMult;
+      if ((strcmp(beamType,"p-p") == 0) ||
+          (strcmp(beamType,"p-")  == 0) ||
+          (strcmp(beamType,"-p")  == 0) ||
+          (strcmp(beamType,"P-P") == 0) ||
+          (strcmp(beamType,"P-")  == 0) ||
+          (strcmp(beamType,"-P")  == 0)) {
+        // Proton run, the event specie is set to kLowMult
+        fEventSpecie = AliRecoParam::kLowMult;
+      } 
+    }
+  } else {
+    AliWarning("Unknown beam type and energy! Setting energy to 0");
+    grpObj->SetBeamEnergy(0);
+    grpObj->SetBeamType("UNKNOWN");
+  }
+
+  UInt_t detectorPattern  = 0;
+  Int_t nDets = 0;
+  TObjArray *detArray = gAlice->Detectors();
+  for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors-1; iDet++) {
+    if (detArray->FindObject(AliDAQ::OfflineModuleName(iDet))) {
+      detectorPattern |= (1 << iDet);
+      nDets++;
+    }
+  }
+  // CTP
+  if (!fMakeTrigger.IsNull() || strcmp(gAlice->GetTriggerDescriptor(),""))
+    detectorPattern |= (1 << AliDAQ::DetectorID("TRG"));
+
+  // HLT
+  if (!fRunHLT.IsNull())
+    detectorPattern |= (1 << AliDAQ::kHLTId);
+
+  grpObj->SetNumberOfDetectors((Char_t)nDets);
+  grpObj->SetDetectorMask((Int_t)detectorPattern);
+  grpObj->SetLHCPeriod("LHC08c");
+  grpObj->SetLHCState("STABLE_BEAMS");
+  grpObj->SetLHCLuminosity(0,(AliGRPObject::Stats)0);
+  grpObj->SetBeamIntensity(0,(AliGRPObject::Stats)0);
+
+  AliMagF *field = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
+  Float_t solenoidField = field ? TMath::Abs(field->SolenoidField()) : 0;
+  Float_t factor =        field ? field->Factor() : 0;
+  Float_t l3current = TMath::Abs(factor)*solenoidField*30000./5.;
+  grpObj->SetL3Current(l3current,(AliGRPObject::Stats)0);
+  
+  if (factor > 0) {
+    grpObj->SetL3Polarity(0);
+    grpObj->SetDipolePolarity(0);
+  }
+  else {
+    grpObj->SetL3Polarity(1);
+    grpObj->SetDipolePolarity(1);
+  }
+
+  if (TMath::Abs(factor) != 0)
+    grpObj->SetDipoleCurrent(6000,(AliGRPObject::Stats)0);
+  else 
+    grpObj->SetDipoleCurrent(0,(AliGRPObject::Stats)0);
+
+  grpObj->SetCavernTemperature(0,(AliGRPObject::Stats)0);
+  
+  //grpMap->Add(new TObjString("fCavernPressure"),new TObjString("0")); ---> not inserted in simulation with the new object, since it is now an AliDCSSensor
+
+  // Now store the entry in OCDB
+  AliCDBManager* man = AliCDBManager::Instance();
+
+  AliCDBId id("GRP/GRP/Data", man->GetRun(), man->GetRun(), 1, 1);
+  AliCDBMetaData *metadata= new AliCDBMetaData();
+
+  metadata->SetResponsible("alice-off@cern.ch");
+  metadata->SetComment("Automatically produced GRP entry for Monte Carlo");
+ 
+  man->Put(grpObj,id,metadata);
+}
+