X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=STEER%2FAliSimulation.cxx;h=4aa7992131bdebcde1e4023547423fa8680b9b96;hb=26b9ac7ac5e19eccdd5b5dcb83e2d688ad118cea;hp=f7a3a0cc27c29b60e5fa2ba4d3c63a2677337f9a;hpb=caf9c464f513368898dc62e8382ebdb833e42603;p=u%2Fmrichter%2FAliRoot.git

diff --git a/STEER/AliSimulation.cxx b/STEER/AliSimulation.cxx
index f7a3a0cc27c..4aa7992131b 100644
--- a/STEER/AliSimulation.cxx
+++ b/STEER/AliSimulation.cxx
@@ -108,10 +108,10 @@
 #include <TVirtualMCApplication.h>
 #include <TGeoManager.h>
 #include <TObjString.h>
-#include <TStopwatch.h>
 #include <TSystem.h>
 #include <TFile.h>
 
+#include "AliCodeTimer.h"
 #include "AliCDBStorage.h"
 #include "AliCDBEntry.h"
 #include "AliCDBManager.h"
@@ -131,17 +131,22 @@
 #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"
 
 ClassImp(AliSimulation)
 
 AliSimulation *AliSimulation::fgInstance = 0;
+const char* AliSimulation::fgkDetectorName[AliSimulation::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT"};
 
 //_____________________________________________________________________________
-AliSimulation::AliSimulation(const char* configFileName, const char* cdbUri,
+AliSimulation::AliSimulation(const char* configFileName,
 			     const char* name, const char* title) :
   TNamed(name, title),
 
@@ -166,13 +171,24 @@ AliSimulation::AliSimulation(const char* configFileName, const char* cdbUri,
   fAlignObjArray(NULL),
   fUseBkgrdVertex(kTRUE),
   fRegionOfInterest(kFALSE),
-  fCDBUri(cdbUri),
+  fCDBUri(""),
   fSpecCDBUri(),
-  fEmbeddingFlag(kFALSE)
+  fRun(-1),
+  fSeed(0),
+  fInitCDBCalled(kFALSE),
+  fInitRunNumberCalled(kFALSE),
+  fSetRunNumberFromDataCalled(kFALSE),
+  fEmbeddingFlag(kFALSE),
+  fRunQA(kTRUE), 
+  fRunHLT("default")
 {
 // create simulation object with default parameters
   fgInstance = this;
   SetGAliceFile("galice.root");
+  
+// for QA
+   for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) 
+	fQACycles[iDet] = 999999;
 }
 
 //_____________________________________________________________________________
@@ -202,7 +218,14 @@ AliSimulation::AliSimulation(const AliSimulation& sim) :
   fRegionOfInterest(sim.fRegionOfInterest),
   fCDBUri(sim.fCDBUri),
   fSpecCDBUri(),
-  fEmbeddingFlag(sim.fEmbeddingFlag)
+  fRun(-1),
+  fSeed(0),
+  fInitCDBCalled(sim.fInitCDBCalled),
+  fInitRunNumberCalled(sim.fInitRunNumberCalled),
+  fSetRunNumberFromDataCalled(sim.fSetRunNumberFromDataCalled),
+  fEmbeddingFlag(sim.fEmbeddingFlag),
+  fRunQA(kTRUE), 
+  fRunHLT(sim.fRunHLT)
 {
 // copy constructor
 
@@ -221,6 +244,10 @@ AliSimulation::AliSimulation(const AliSimulation& sim) :
     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];
 }
 
 //_____________________________________________________________________________
@@ -249,6 +276,8 @@ AliSimulation::~AliSimulation()
 
   fSpecCDBUri.Delete();
   if (fgInstance==this) fgInstance = 0;
+
+  AliCodeTimer::Instance()->Print();
 }
 
 
@@ -261,25 +290,38 @@ void AliSimulation::SetNumberOfEvents(Int_t nEvents)
 }
 
 //_____________________________________________________________________________
-void AliSimulation::InitCDBStorage()
+void AliSimulation::InitCDB()
 {
 // activate a default CDB storage
 // First check if we have any CDB storage set, because it is used 
 // to retrieve the calibration and alignment constants
 
+  if (fInitCDBCalled) return;
+  fInitCDBCalled = kTRUE;
+
   AliCDBManager* man = AliCDBManager::Instance();
   if (man->IsDefaultStorageSet())
   {
     AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
     AliWarning("Default CDB storage has been already set !");
-    AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fCDBUri.Data()));
+    AliWarning(Form("Ignoring the default storage declared in AliSimulation: %s",fCDBUri.Data()));
     AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
-    fCDBUri = "";
+    fCDBUri = man->GetDefaultStorage()->GetURI();
   }
   else {
-    AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
-    AliDebug(2, Form("Default CDB storage is set to: %s",fCDBUri.Data()));
-    AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+    if (fCDBUri.Length() > 0) 
+    {
+    	AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+    	AliDebug(2, Form("Default CDB storage is set to: %s", fCDBUri.Data()));
+    	AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+    } else {
+    	fCDBUri="local://$ALICE_ROOT";
+    	AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+    	AliWarning("Default CDB storage not yet set !!!!");
+    	AliWarning(Form("Setting it now to: %s", fCDBUri.Data()));
+    	AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+    		
+    }
     man->SetDefaultStorage(fCDBUri);
   }
 
@@ -292,7 +334,47 @@ void AliSimulation::InitCDBStorage()
     AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
     man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
   }
+      
+}
+
+//_____________________________________________________________________________
+void AliSimulation::InitRunNumber(){
+// check run number. If not set, set it to 0 !!!!
+  
+  if (fInitRunNumberCalled) return;
+  fInitRunNumberCalled = kTRUE;
+  
+  AliCDBManager* man = AliCDBManager::Instance();
+  if (man->GetRun() >= 0)
+  {
+    	AliFatal(Form("Run number cannot be set in AliCDBManager before start of simulation: "
+			"Use external variable DC_RUN or AliSimulation::SetRun()!"));
+  }
+    
+  if(fRun >= 0) {
+    	AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+    	AliDebug(2, Form("Setting CDB run number to: %d",fRun));
+    	AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+  } else {
+    	fRun=0;
+    	AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+    	AliWarning("Run number not yet set !!!!");
+    	AliWarning(Form("Setting it now to: %d", fRun));
+    	AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+    	
+  }
+  man->SetRun(fRun);
+
   man->Print();
+
+}
+
+//_____________________________________________________________________________
+void AliSimulation::SetCDBLock() {
+  // Set CDB lock: from now on it is forbidden to reset the run number
+  // or the default storage or to activate any further storage!
+  
+  AliCDBManager::Instance()->SetLock(1);
 }
 
 //_____________________________________________________________________________
@@ -321,6 +403,67 @@ void AliSimulation::SetSpecificStorage(const char* calibType, const char* uri) {
 
 }
 
+//_____________________________________________________________________________
+void AliSimulation::SetRunNumber(Int_t run)
+{
+// sets run number
+// Activate it later within the Run() method
+
+	fRun = run;
+}
+
+//_____________________________________________________________________________
+void AliSimulation::SetSeed(Int_t seed)
+{
+// sets seed number
+// Activate it later within the Run() method
+
+	fSeed = seed;
+}
+
+//_____________________________________________________________________________
+Bool_t AliSimulation::SetRunNumberFromData()
+{
+  // Set the CDB manager run number
+  // The run number is retrieved from gAlice
+
+    if (fSetRunNumberFromDataCalled) return kTRUE;
+    fSetRunNumberFromDataCalled = kTRUE;    
+  
+    AliCDBManager* man = AliCDBManager::Instance();
+    Int_t runData = -1, runCDB = -1;
+  
+    AliRunLoader* runLoader = LoadRun("READ");
+    if (!runLoader) return kFALSE;
+    else {
+    	runData = runLoader->GetAliRun()->GetHeader()->GetRun();
+	delete runLoader;
+    }
+  
+    runCDB = man->GetRun();
+    if(runCDB >= 0) {
+	if (runCDB != runData) {
+    		AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+    		AliWarning(Form("A run number was previously set in AliCDBManager: %d !", runCDB));
+    		AliWarning(Form("It will be replaced with the run number got from run header: %d !", runData));
+    		AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");	
+	}
+   	
+    }
+      
+    man->SetRun(runData);
+    fRun = runData;
+    
+    if(man->GetRun() < 0) {
+    	AliError("Run number not properly initalized!");
+	return kFALSE;
+    }
+  
+    man->Print();
+    
+    return kTRUE;
+}
+
 //_____________________________________________________________________________
 void AliSimulation::SetConfigFile(const char* fileName)
 {
@@ -369,15 +512,25 @@ Bool_t AliSimulation::MisalignGeometry(AliRunLoader *runLoader)
   // then applied to the TGeo geometry.
   // Finally an overlaps check is performed.
 
+  if (!AliGeomManager::GetGeometry() || !AliGeomManager::GetGeometry()->IsClosed()) {
+    AliError("Can't apply the misalignment! Geometry is not loaded or it is still opened!");
+    return kFALSE;
+  }  
+  
+  // initialize CDB storage, run number, set CDB lock
+  InitCDB();
+//  if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
+  SetCDBLock();
+    
   Bool_t delRunLoader = kFALSE;
   if (!runLoader) {
     runLoader = LoadRun("READ");
     if (!runLoader) return kFALSE;
     delRunLoader = kTRUE;
   }
-
+  
   // Export ideal geometry 
-  if (gGeoManager) gGeoManager->Export("geometry.root");
+  if(!gAlice->IsRootGeometry()) AliGeomManager::GetGeometry()->Export("geometry.root");
 
   // Load alignment data from CDB and apply to geometry through AliGeomManager
   if(fLoadAlignFromCDB){
@@ -390,29 +543,23 @@ Bool_t AliSimulation::MisalignGeometry(AliRunLoader *runLoader)
       AliModule* det = (AliModule*) detArray->At(iDet);
       if (!det || !det->IsActive()) continue;
       if (IsSelected(det->GetName(), detStr)) {
-	//add det to list of dets to be aligned from CDB
-	loadAlObjsListOfDets += det->GetName();
-	loadAlObjsListOfDets += " ";
+        //add det to list of dets to be aligned from CDB
+        loadAlObjsListOfDets += det->GetName();
+        loadAlObjsListOfDets += " ";
       }
     } // end loop over detectors
-    (AliGeomManager::Instance())->ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
+    loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
+    AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
   }else{
     // Check if the array with alignment objects was
     // provided by the user. If yes, apply the objects
     // to the present TGeo geometry
     if (fAlignObjArray) {
-      if (gGeoManager && gGeoManager->IsClosed()) {
-	if ((AliGeomManager::Instance())->ApplyAlignObjsToGeom(fAlignObjArray) == kFALSE) {
-	  AliError("The misalignment of one or more volumes failed!"
-		   "Compare the list of simulated detectors and the list of detector alignment data!");
-	  if (delRunLoader) delete runLoader;
-	  return kFALSE;
-	}
-      }
-      else {
-	AliError("Can't apply the misalignment! gGeoManager doesn't exist or it is still opened!");
-	if (delRunLoader) delete runLoader;
-	return kFALSE;
+      if (AliGeomManager::ApplyAlignObjsToGeom(*fAlignObjArray) == kFALSE) {
+        AliError("The misalignment of one or more volumes failed!"
+                 "Compare the list of simulated detectors and the list of detector alignment data!");
+        if (delRunLoader) delete runLoader;
+        return kFALSE;
       }
     }
   }
@@ -432,28 +579,6 @@ Bool_t AliSimulation::MisalignGeometry(AliRunLoader *runLoader)
 
   if (delRunLoader) delete runLoader;
 
-  // Update the TGeoPhysicalNodes
-  gGeoManager->RefreshPhysicalNodes();
-
-  return kTRUE;
-}
-
-
-//_____________________________________________________________________________
-Bool_t AliSimulation::SetRunNumber()
-{
-  // Set the CDB manager run number
-  // The run number is retrieved from gAlice
-
-  if(AliCDBManager::Instance()->GetRun() < 0) {
-    AliRunLoader* runLoader = LoadRun("READ");
-    if (!runLoader) return kFALSE;
-    else {
-      AliCDBManager::Instance()->SetRun(runLoader->GetAliRun()->GetRunNumber());
-      AliInfo(Form("Run number: %d",AliCDBManager::Instance()->GetRun()));
-      delete runLoader;
-    }
-  }
   return kTRUE;
 }
 
@@ -480,38 +605,60 @@ Bool_t AliSimulation::Run(Int_t nEvents)
 {
 // run the generation, simulation and digitization
 
-  InitCDBStorage();
+ 
+  AliCodeTimerAuto("")
+  
+  // Load run number and seed from environmental vars
+  ProcessEnvironmentVars();
 
+  gRandom->SetSeed(fSeed);
+   
   if (nEvents > 0) fNEvents = nEvents;
 
   // generation and simulation -> hits
   if (fRunGeneration) {
     if (!RunSimulation()) if (fStopOnError) return kFALSE;
   }
-
-  // Set run number in CDBManager (if it is not already set in RunSimulation)
-  if (!SetRunNumber()) if (fStopOnError) return kFALSE;
+           
+  // initialize CDB storage from external environment
+  // (either CDB manager or AliSimulation setters),
+  // if not already done in RunSimulation()
+  InitCDB();
+  
+  // Set run number in CDBManager from data 
+  // From this point on the run number must be always loaded from data!
+  if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
+  
+  // Set CDB lock: from now on it is forbidden to reset the run number
+  // or the default storage or to activate any further storage!
+  SetCDBLock();
 
   // If RunSimulation was not called, load the geometry and misalign it
-  if (!gGeoManager) {
-    TGeoManager::Import("geometry.root");
-    if (!gGeoManager) if (fStopOnError) return kFALSE;
-    // Initialize the geometry manager (if not already done)
+  if (!AliGeomManager::GetGeometry()) {
+    // Initialize the geometry manager
+    AliGeomManager::LoadGeometry("geometry.root");
+    if (!AliGeomManager::GetGeometry()) if (fStopOnError) return kFALSE;
+    // Misalign geometry
     if(!MisalignGeometry()) if (fStopOnError) return kFALSE;
   }
 
   // hits -> summable digits
   if (!fMakeSDigits.IsNull()) {
     if (!RunSDigitization(fMakeSDigits)) if (fStopOnError) return kFALSE;
+ 
   }
+  
 
-  // summable digits -> digits
+  
+  // summable digits -> digits  
   if (!fMakeDigits.IsNull()) {
     if (!RunDigitization(fMakeDigits, fMakeDigitsFromHits)) {
       if (fStopOnError) return kFALSE;
     }
-  }
+   }
 
+  
+  
   // hits -> digits
   if (!fMakeDigitsFromHits.IsNull()) {
     if (fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
@@ -525,11 +672,15 @@ Bool_t AliSimulation::Run(Int_t nEvents)
     }
   }
 
+  
+  
   // digits -> trigger
-  if (!RunTrigger(fMakeTrigger)) {
+  if (!RunTrigger(fMakeTrigger,fMakeDigits)) {
     if (fStopOnError) return kFALSE;
   }
 
+  
+  
   // digits -> raw data
   if (!fWriteRawData.IsNull()) {
     if (!WriteRawData(fWriteRawData, fRawDataFileName, 
@@ -538,47 +689,75 @@ Bool_t AliSimulation::Run(Int_t nEvents)
     }
   }
 
+  
+  
+  // run HLT simulation
+  if (!fRunHLT.IsNull()) {
+    if (!RunHLT()) {
+      if (fStopOnError) return kFALSE;
+    }
+  }
+  
+ // //QA
+//	if (fRunQA) {
+//		Bool_t rv = RunQA() ; 
+//		if (!rv)
+//			if (fStopOnError) 
+//				return kFALSE ;   	
+//	}
+
+  // Cleanup of CDB manager: cache and active storages!
+  AliCDBManager::Instance()->ClearCache();
+
   return kTRUE;
 }
 
 //_____________________________________________________________________________
-Bool_t AliSimulation::RunTrigger(const char* descriptors)
+Bool_t AliSimulation::RunTrigger(const char* config, const char* detectors)
 {
   // run the trigger
 
-   TStopwatch stopwatch;
-   stopwatch.Start();
+  AliCodeTimerAuto("")
 
+  // initialize CDB storage from external environment
+  // (either CDB manager or AliSimulation setters),
+  // if not already done in RunSimulation()
+  InitCDB();
+  
+  // Set run number in CDBManager from data 
+  // From this point on the run number must be always loaded from data!
+  if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
+  
+  // Set CDB lock: from now on it is forbidden to reset the run number
+  // or the default storage or to activate any further storage!
+  SetCDBLock();
+   
    AliRunLoader* runLoader = LoadRun("READ");
    if (!runLoader) return kFALSE;
-   TString des = descriptors;
+   TString trconfiguration = config;
 
-   if (des.IsNull()) {
+   if (trconfiguration.IsNull()) {
      if (gAlice->GetTriggerDescriptor() != "") {
-       des = gAlice->GetTriggerDescriptor();
-     }
-     else {
-       AliWarning("No trigger descriptor is specified. Skipping the trigger simulation...");
-       return kTRUE;
+       trconfiguration = gAlice->GetTriggerDescriptor();
      }
+     else
+       AliWarning("No trigger descriptor is specified. Loading the one that is in the CDB.");
    }
 
    runLoader->MakeTree( "GG" );
    AliCentralTrigger* aCTP = runLoader->GetTrigger();
-  // Load Descriptors
-   aCTP->LoadDescriptor( des );
+   // Load Configuration
+   if (!aCTP->LoadConfiguration( trconfiguration ))
+     return kFALSE;
 
-  // digits -> trigger
-   if( !aCTP->RunTrigger( runLoader ) ) {
+   // digits -> trigger
+   if( !aCTP->RunTrigger( runLoader , detectors ) ) {
       if (fStopOnError) {
-    //  delete aCTP;
-         return kFALSE;
+	//  delete aCTP;
+	return kFALSE;
       }
    }
 
-   AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
-           stopwatch.RealTime(),stopwatch.CpuTime()));
-
    delete runLoader;
 
    return kTRUE;
@@ -601,9 +780,14 @@ Bool_t AliSimulation::RunSimulation(Int_t nEvents)
 {
 // run the generation and simulation
 
-  TStopwatch stopwatch;
-  stopwatch.Start();
+  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;
@@ -618,7 +802,7 @@ Bool_t AliSimulation::RunSimulation(Int_t nEvents)
   StdoutToAliInfo(StderrToAliError(
     gAlice->Init(fConfigFileName.Data());
   ););
-
+  
   // Get the trigger descriptor string
   // Either from AliSimulation or from
   // gAlice
@@ -630,7 +814,6 @@ Bool_t AliSimulation::RunSimulation(Int_t nEvents)
     gAlice->SetTriggerDescriptor(fMakeTrigger.Data());
 
   // Set run number in CDBManager
-  AliCDBManager::Instance()->SetRun(gAlice->GetRunNumber());
   AliInfo(Form("Run number: %d",AliCDBManager::Instance()->GetRun()));
 
   AliRunLoader* runLoader = gAlice->GetRunLoader();
@@ -640,15 +823,13 @@ Bool_t AliSimulation::RunSimulation(Int_t nEvents)
              return kFALSE;
   }
   SetGAliceFile(runLoader->GetFileName());
- 
+      
   // Misalign geometry
 #if ROOT_VERSION_CODE < 331527
+  AliGeomManager::SetGeometry(gGeoManager);
   MisalignGeometry(runLoader);
 #endif
 
-  // Export (mis)aligned geometry 
-  if (gGeoManager) gGeoManager->Export("misaligned_geometry.root");
-
 //   AliRunLoader* runLoader = gAlice->GetRunLoader();
 //   if (!runLoader) {
 //     AliError(Form("gAlice has no run loader object. "
@@ -715,9 +896,6 @@ Bool_t AliSimulation::RunSimulation(Int_t nEvents)
 
   delete runLoader;
 
-  AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
-	       stopwatch.RealTime(),stopwatch.CpuTime()));
-
   return kTRUE;
 }
 
@@ -726,9 +904,13 @@ Bool_t AliSimulation::RunSDigitization(const char* detectors)
 {
 // run the digitization and produce summable digits
 
-  TStopwatch stopwatch;
-  stopwatch.Start();
+  AliCodeTimerAuto("")
 
+  // initialize CDB storage, run number, set CDB lock
+  InitCDB();
+  if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
+  SetCDBLock();
+  
   AliRunLoader* runLoader = LoadRun();
   if (!runLoader) return kFALSE;
 
@@ -739,11 +921,9 @@ Bool_t AliSimulation::RunSDigitization(const char* detectors)
     if (!det || !det->IsActive()) continue;
     if (IsSelected(det->GetName(), detStr)) {
       AliInfo(Form("creating summable digits for %s", det->GetName()));
-      TStopwatch stopwatchDet;
-      stopwatchDet.Start();
+      AliCodeTimerAuto(Form("creating summable digits for %s", det->GetName()));
+	  
       det->Hits2SDigits();
-      AliInfo(Form("Execution time for %s: R:%.2fs C:%.2fs",
-	   det->GetName(),stopwatchDet.RealTime(),stopwatchDet.CpuTime()));
     }
   }
 
@@ -755,9 +935,6 @@ Bool_t AliSimulation::RunSDigitization(const char* detectors)
 
   delete runLoader;
 
-  AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
-	   stopwatch.RealTime(),stopwatch.CpuTime()));
-
   return kTRUE;
 }
 
@@ -768,9 +945,13 @@ Bool_t AliSimulation::RunDigitization(const char* detectors,
 {
 // run the digitization and produce digits from sdigits
 
-  TStopwatch stopwatch;
-  stopwatch.Start();
+  AliCodeTimerAuto("")
 
+  // initialize CDB storage, run number, set CDB lock
+  InitCDB();
+  if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
+  SetCDBLock();
+  
   while (AliRunLoader::GetRunLoader()) delete AliRunLoader::GetRunLoader();
   if (gAlice) delete gAlice;
   gAlice = NULL;
@@ -822,9 +1003,6 @@ Bool_t AliSimulation::RunDigitization(const char* detectors,
 
   delete manager;
 
-  AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
-	       stopwatch.RealTime(),stopwatch.CpuTime()));
-  
   return kTRUE;
 }
 
@@ -833,9 +1011,13 @@ Bool_t AliSimulation::RunHitsDigitization(const char* detectors)
 {
 // run the digitization and produce digits from hits
 
-  TStopwatch stopwatch;
-  stopwatch.Start();
+  AliCodeTimerAuto("")
 
+  // initialize CDB storage, run number, set CDB lock
+  InitCDB();
+  if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
+  SetCDBLock();
+  
   AliRunLoader* runLoader = LoadRun("READ");
   if (!runLoader) return kFALSE;
 
@@ -860,9 +1042,6 @@ Bool_t AliSimulation::RunHitsDigitization(const char* detectors)
   //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
 
-  AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
-	       stopwatch.RealTime(),stopwatch.CpuTime()));
-
   return kTRUE;
 }
 
@@ -880,8 +1059,7 @@ Bool_t AliSimulation::WriteRawData(const char* detectors,
 // to a root file.
 // If deleteIntermediateFiles is true, the DATE file is deleted afterwards.
 
-  TStopwatch stopwatch;
-  stopwatch.Start();
+  AliCodeTimerAuto("")
 
   if (!WriteRawFiles(detectors)) {
     if (fStopOnError) return kFALSE;
@@ -914,9 +1092,6 @@ Bool_t AliSimulation::WriteRawData(const char* detectors,
     }
   }
 
-  AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
-	       stopwatch.RealTime(),stopwatch.CpuTime()));
-
   return kTRUE;
 }
 
@@ -925,6 +1100,8 @@ Bool_t AliSimulation::WriteRawFiles(const char* detectors)
 {
 // convert the digits to raw data DDL files
 
+  AliCodeTimerAuto("")
+  
   AliRunLoader* runLoader = LoadRun("READ");
   if (!runLoader) return kFALSE;
 
@@ -964,6 +1141,7 @@ Bool_t AliSimulation::WriteRawFiles(const char* detectors)
   }
 
   delete runLoader;
+  
   return kTRUE;
 }
 
@@ -972,6 +1150,8 @@ Bool_t AliSimulation::ConvertRawFilesToDate(const char* dateFileName)
 {
 // convert raw data DDL files to a DATE file with the program "dateStream"
 
+  AliCodeTimerAuto("")
+  
   char* path = gSystem->Which(gSystem->Getenv("PATH"), "dateStream");
   if (!path) {
     AliError("the program dateStream was not found");
@@ -987,8 +1167,8 @@ Bool_t AliSimulation::ConvertRawFilesToDate(const char* dateFileName)
   char command[256];
   // Note the option -s. It is used in order to avoid
   // the generation of SOR/EOR events.
-  sprintf(command, "dateStream -s -D -o %s -# %d -C", 
-	  dateFileName, runLoader->GetNumberOfEvents());
+  sprintf(command, "dateStream -c -s -D -o %s -# %d -C -run %d", 
+	  dateFileName, runLoader->GetNumberOfEvents(),runLoader->GetHeader()->GetRun());
   FILE* pipe = gSystem->OpenPipe(command, "w");
 
   for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
@@ -1041,7 +1221,7 @@ Bool_t AliSimulation::ConvertDateToRoot(const char* dateFileName,
   const Int_t kDBSize = 2000000000;
   const Int_t kTagDBSize = 1000000000;
   const Bool_t kFilter = kFALSE;
-  const Int_t kCompression = 0;
+  const Int_t kCompression = 1;
 
   char* path = gSystem->Which(gSystem->Getenv("PATH"), "alimdc");
   if (!path) {
@@ -1099,6 +1279,7 @@ AliRunLoader* AliSimulation::LoadRun(const char* mode) const
     return NULL;
   }
   runLoader->LoadgAlice();
+  runLoader->LoadHeader();
   gAlice = runLoader->GetAliRun();
   if (!gAlice) {
     AliError(Form("no gAlice object found in file %s", 
@@ -1193,6 +1374,7 @@ Bool_t AliSimulation::IsSelected(TString detName, TString& detectors) const
   return result;
 }
 
+//_____________________________________________________________________________
 Bool_t AliSimulation::ConvertRaw2SDigits(const char* rawDirectory, const char* esdFileName) 
 {
 //
@@ -1215,9 +1397,9 @@ Bool_t AliSimulation::ConvertRaw2SDigits(const char* rawDirectory, const char* e
     StdoutToAliInfo(StderrToAliError(gAlice->Init(fConfigFileName.Data());););
 //
 //  Initialize CDB     
-    InitCDBStorage();
-    AliCDBManager* man = AliCDBManager::Instance();
-    man->SetRun(0); // Should this come from rawdata header ?
+    InitCDB();
+    //AliCDBManager* man = AliCDBManager::Instance();
+    //man->SetRun(0); // Should this come from rawdata header ?
     
     Int_t iDet;
     //
@@ -1240,7 +1422,18 @@ Bool_t AliSimulation::ConvertRaw2SDigits(const char* rawDirectory, const char* e
     }
     //
     // Create the RawReader
-    AliRawReaderFile* rawReader = new AliRawReaderFile(rawDirectory);
+    TString fileName(rawDirectory);
+    AliRawReader* rawReader = 0x0;
+    if (fileName.EndsWith("/")) {
+      rawReader = new AliRawReaderFile(fileName);
+    } else if (fileName.EndsWith(".root")) {
+      rawReader = new AliRawReaderRoot(fileName);
+    } else if (!fileName.IsNull()) {
+      rawReader = new AliRawReaderDate(fileName);
+      rawReader->SelectEvents(7);
+    }
+//     if (!fEquipIdMap.IsNull() && fRawReader)
+//       fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
     //
     // Get list of detectors
     TObjArray* detArray = runLoader->GetAliRun()->Detectors();
@@ -1248,6 +1441,7 @@ Bool_t AliSimulation::ConvertRaw2SDigits(const char* rawDirectory, const char* e
     // Get Header
     AliHeader* header = runLoader->GetHeader();
     //
+    TString detStr = fMakeSDigits;
     // Event loop
     Int_t nev = 0;
     while(kTRUE) {
@@ -1256,11 +1450,15 @@ Bool_t AliSimulation::ConvertRaw2SDigits(const char* rawDirectory, const char* e
 	// Detector loop
 	for (iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
 	    AliModule* det = (AliModule*) detArray->At(iDet);
-	    AliInfo(Form("Calling Raw2SDigits for %s\n", det->GetName()));
-	    det->Raw2SDigits(rawReader);
-	    rawReader->Reset();
+	    if (!det || !det->IsActive()) continue;
+	    if (IsSelected(det->GetName(), detStr)) {
+	      AliInfo(Form("Calling Raw2SDigits for %s\n", det->GetName()));
+	      det->Raw2SDigits(rawReader);
+	      rawReader->Reset();
+	    }
 	} // detectors
 
+
 	//
 	//  If ESD information available obtain reconstructed vertex and store in header.
 	if (esdOK) {
@@ -1293,3 +1491,170 @@ Bool_t AliSimulation::ConvertRaw2SDigits(const char* rawDirectory, const char* e
 
     return kTRUE;
 }
+
+//_____________________________________________________________________________
+Int_t AliSimulation::GetDetIndex(const char* detector)
+{
+  // return the detector index corresponding to detector
+  Int_t index = -1 ; 
+  for (index = 0; index < fgkNDetectors ; index++) {
+    if ( strcmp(detector, fgkDetectorName[index]) == 0 )
+	  break ; 
+  }	
+  return index ; 
+}
+
+//_____________________________________________________________________________
+Bool_t AliSimulation::RunHLT()
+{
+  // Run the HLT simulation
+  // HLT simulation is implemented in HLT/sim/AliHLTSimulation
+  // Disabled if fRunHLT is empty, default vaule is "default".
+  // 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
+  //
+  // The libraries to be loaded can be specified as an option.
+  // <pre>
+  // AliSimulation sim;
+  // sim.SetRunHLT("libAliHLTSample.so");
+  // </pre>
+  // will only load <tt>libAliHLTSample.so</tt>
+
+  // Other available options:
+  // \li loglevel=<i>level</i> <br>
+  //     logging level for this processing
+  // \li alilog=off
+  //     disable redirection of log messages to AliLog class
+  // \li config=<i>macro</i>
+  //     configuration macro
+  // \li localrec=<i>configuration</i>
+  //     comma separated list of configurations to be run during simulation
+
+  int iResult=0;
+  AliRunLoader* pRunLoader = LoadRun("READ");
+  if (!pRunLoader) return kFALSE;
+
+  // initialize CDB storage, run number, set CDB lock
+  InitCDB();
+  if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
+  SetCDBLock();
+  
+  // load the library dynamically
+  gSystem->Load(ALIHLTSIMULATION_LIBRARY);
+
+  // check for the library version
+  AliHLTSimulationGetLibraryVersion_t fctVersion=(AliHLTSimulationGetLibraryVersion_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_GET_LIBRARY_VERSION));
+  if (!fctVersion) {
+    AliError(Form("can not load library %s", ALIHLTSIMULATION_LIBRARY));
+    return kFALSE;
+  }
+  if (fctVersion()!= ALIHLTSIMULATION_LIBRARY_VERSION) {
+    AliError(Form("%s version does not match: compiled for version %d, loaded %d", ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_LIBRARY_VERSION, fctVersion()));
+    return kFALSE;
+  }
+
+  // print compile info
+  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";
+    AliInfo(Form("%s build on %s (%s)", ALIHLTSIMULATION_LIBRARY, date, time));
+  } else {
+    AliInfo(Form("no build info available for %s", ALIHLTSIMULATION_LIBRARY));
+  }
+
+  // create instance of the HLT simulation
+  AliHLTSimulationCreateInstance_t fctCreate=(AliHLTSimulationCreateInstance_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_CREATE_INSTANCE));
+  AliHLTSimulation* pHLT=NULL;
+  if (fctCreate==NULL || (pHLT=(fctCreate()))==NULL) {
+    AliError(Form("can not create instance of HLT simulation (creator %p)", fctCreate));
+    return kFALSE;    
+  }
+
+  // init the HLT simulation
+  if (fRunHLT.CompareTo("default")==0) fRunHLT="";
+  AliHLTSimulationInit_t fctInit=(AliHLTSimulationInit_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_INIT));
+  if (fctInit==NULL || (iResult=(fctInit(pHLT, pRunLoader, fRunHLT.Data())))<0) {
+    AliError(Form("can not init HLT simulation: error %d (init %p)", iResult, fctInit));
+  } else {
+    // run the HLT simulation
+    AliHLTSimulationRun_t fctRun=(AliHLTSimulationRun_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_RUN));
+    if (fctRun==NULL || (iResult=(fctRun(pHLT, pRunLoader)))<0) {
+      AliError(Form("can not run HLT simulation: error %d (run %p)", iResult, fctRun));
+    }
+  }
+
+  // delete the instance
+  AliHLTSimulationDeleteInstance_t fctDelete=(AliHLTSimulationDeleteInstance_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_DELETE_INSTANCE));
+  if (fctDelete==NULL || fctDelete(pHLT)<0) {
+    AliError(Form("can not delete instance of HLT simulation (creator %p)", fctDelete));
+  }
+  pHLT=NULL;
+
+  return iResult>=0?kTRUE:kFALSE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliSimulation::RunQA()
+{
+	// run the QA on summable hits, digits or digits
+
+	AliQADataMakerSteer qas ; 
+    qas.SetRunLoader(gAlice->GetRunLoader()) ;
+
+	Bool_t rv =  qas.Run("ALL", AliQA::kHITS) ; 
+//	qas.Reset() ; 
+	rv *= qas.Run(fMakeSDigits.Data(), AliQA::kSDIGITS) ;   
+//	qas.Reset() ; 
+	rv *= qas.Run(fMakeDigits.Data(), AliQA::kDIGITS) ; 	
+//	qas.Reset() ; 
+	rv *= qas.Run(fMakeDigitsFromHits.Data(), AliQA::kDIGITS) ; 
+
+	return rv ; 
+}
+
+//_____________________________________________________________________________
+void AliSimulation::ProcessEnvironmentVars()
+{
+// Extract run number and random generator seed from env variables
+
+    AliInfo("Processing environment variables");
+    
+    // Random Number seed
+    
+    // first check that seed is not already set
+    if (fSeed == 0) {
+    	if (gSystem->Getenv("CONFIG_SEED")) {
+     	 	fSeed = atoi(gSystem->Getenv("CONFIG_SEED"));
+    	}
+    } else {
+    	if (gSystem->Getenv("CONFIG_SEED")) {
+    		AliInfo(Form("Seed for random number generation already set (%d)"
+			     ": CONFIG_SEED variable ignored!", fSeed));
+    	}
+    }
+   
+    AliInfo(Form("Seed for random number generation = %d ", fSeed)); 
+
+    // Run Number
+    
+    // first check that run number is not already set
+    if(fRun < 0) {    
+    	if (gSystem->Getenv("DC_RUN")) {
+		fRun = atoi(gSystem->Getenv("DC_RUN"));
+    	}
+    } else {
+    	if (gSystem->Getenv("DC_RUN")) {
+    		AliInfo(Form("Run number already set (%d): DC_RUN variable ignored!", fRun));
+    	}
+    }
+    
+    AliInfo(Form("Run number = %d", fRun)); 
+}