X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;ds=sidebyside;f=STEER%2FAliSimulation.cxx;h=2c7b8935ff7b8646c92ed18123730491f942fa98;hb=87586a906a461adf5869b0f22f3446994f13b7c0;hp=a235651a49ce4983c3d98c258a89786269e28588;hpb=8ec1d12bb2f0ae97f76670388d010796c22081df;p=u%2Fmrichter%2FAliRoot.git

diff --git a/STEER/AliSimulation.cxx b/STEER/AliSimulation.cxx
index a235651a49c..2c7b8935ff7 100644
--- a/STEER/AliSimulation.cxx
+++ b/STEER/AliSimulation.cxx
@@ -137,13 +137,17 @@
 #include "AliHeader.h"
 #include "AliGenEventHeader.h"
 #include "AliMC.h"
+#include "AliHLTSimulation.h"
+#include "AliQADataMakerSteer.h"
+#include "AliSysInfo.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),
 
@@ -158,6 +162,7 @@ AliSimulation::AliSimulation(const char* configFileName, const char* cdbUri,
   fWriteRawData(""),
   fRawDataFileName(""),
   fDeleteIntermediateFiles(kFALSE),
+  fWriteSelRawData(kFALSE),
   fStopOnError(kFALSE),
 
   fNEvents(1),
@@ -168,13 +173,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;
 }
 
 //_____________________________________________________________________________
@@ -192,6 +208,7 @@ AliSimulation::AliSimulation(const AliSimulation& sim) :
   fWriteRawData(sim.fWriteRawData),
   fRawDataFileName(""),
   fDeleteIntermediateFiles(kFALSE),
+  fWriteSelRawData(kFALSE),
   fStopOnError(sim.fStopOnError),
 
   fNEvents(sim.fNEvents),
@@ -204,7 +221,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
 
@@ -223,6 +247,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];
 }
 
 //_____________________________________________________________________________
@@ -265,12 +293,15 @@ 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())
   {
@@ -278,12 +309,22 @@ void AliSimulation::InitCDBStorage()
     AliWarning("Default CDB storage has been already set !");
     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);
   }
 
@@ -296,7 +337,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);
 }
 
 //_____________________________________________________________________________
@@ -325,6 +406,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)
 {
@@ -377,13 +519,19 @@ Bool_t AliSimulation::MisalignGeometry(AliRunLoader *runLoader)
     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(!gAlice->IsRootGeometry()) AliGeomManager::GetGeometry()->Export("geometry.root");
 
@@ -403,6 +551,7 @@ Bool_t AliSimulation::MisalignGeometry(AliRunLoader *runLoader)
         loadAlObjsListOfDets += " ";
       }
     } // end loop over detectors
+    loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
     AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
   }else{
     // Check if the array with alignment objects was
@@ -436,25 +585,6 @@ Bool_t AliSimulation::MisalignGeometry(AliRunLoader *runLoader)
   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;
-}
-
 //_____________________________________________________________________________
 void AliSimulation::MergeWith(const char* fileName, Int_t nSignalPerBkgrd)
 {
@@ -478,19 +608,33 @@ Bool_t AliSimulation::Run(Int_t nEvents)
 {
 // run the generation, simulation and digitization
 
+ 
   AliCodeTimerAuto("")
   
-  InitCDBStorage();
+  // 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 (!AliGeomManager::GetGeometry()) {
@@ -501,18 +645,26 @@ Bool_t AliSimulation::Run(Int_t nEvents)
     if(!MisalignGeometry()) if (fStopOnError) return kFALSE;
   }
 
+
   // hits -> summable digits
+  AliSysInfo::AddStamp("Start_sdigitization");
   if (!fMakeSDigits.IsNull()) {
     if (!RunSDigitization(fMakeSDigits)) if (fStopOnError) return kFALSE;
+ 
   }
-
-  // summable digits -> digits
+  AliSysInfo::AddStamp("Stop_sdigitization");
+  
+  AliSysInfo::AddStamp("Start_digitization");  
+  // summable digits -> digits  
   if (!fMakeDigits.IsNull()) {
     if (!RunDigitization(fMakeDigits, fMakeDigitsFromHits)) {
       if (fStopOnError) return kFALSE;
     }
-  }
+   }
+  AliSysInfo::AddStamp("Stop_digitization");
 
+  
+  
   // hits -> digits
   if (!fMakeDigitsFromHits.IsNull()) {
     if (fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
@@ -526,53 +678,89 @@ 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, 
-		      fDeleteIntermediateFiles)) {
+		      fDeleteIntermediateFiles,fWriteSelRawData)) {
       if (fStopOnError) return kFALSE;
     }
   }
 
+  
+  
+  // 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
 
   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;
       }
    }
 
@@ -600,6 +788,12 @@ Bool_t AliSimulation::RunSimulation(Int_t nEvents)
 
   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;
@@ -614,7 +808,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
@@ -635,7 +829,7 @@ Bool_t AliSimulation::RunSimulation(Int_t nEvents)
              return kFALSE;
   }
   SetGAliceFile(runLoader->GetFileName());
- 
+      
   // Misalign geometry
 #if ROOT_VERSION_CODE < 331527
   AliGeomManager::SetGeometry(gGeoManager);
@@ -702,13 +896,13 @@ Bool_t AliSimulation::RunSimulation(Int_t nEvents)
   }
 
   AliInfo("running gAlice");
+  AliSysInfo::AddStamp("Start_simulation");
   StdoutToAliInfo(StderrToAliError(
     gAlice->Run(nEvents);
   ););
-
+  AliSysInfo::AddStamp("Stop_simulation");
   delete runLoader;
 
-
   return kTRUE;
 }
 
@@ -716,9 +910,14 @@ Bool_t AliSimulation::RunSimulation(Int_t nEvents)
 Bool_t AliSimulation::RunSDigitization(const char* detectors)
 {
 // run the digitization and produce summable digits
-
+  static Int_t eventNr=0;
   AliCodeTimerAuto("")
 
+  // initialize CDB storage, run number, set CDB lock
+  InitCDB();
+  if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
+  SetCDBLock();
+  
   AliRunLoader* runLoader = LoadRun();
   if (!runLoader) return kFALSE;
 
@@ -731,6 +930,7 @@ Bool_t AliSimulation::RunSDigitization(const char* detectors)
       AliInfo(Form("creating summable digits for %s", det->GetName()));
       AliCodeTimerAuto(Form("creating summable digits for %s", det->GetName()));
       det->Hits2SDigits();
+      AliSysInfo::AddStamp(Form("Digit_%s_%d",det->GetName(),eventNr), 0,1, eventNr);
     }
   }
 
@@ -739,7 +939,7 @@ Bool_t AliSimulation::RunSDigitization(const char* detectors)
                   detStr.Data()));
     if (fStopOnError) return kFALSE;
   }
-
+  eventNr++;
   delete runLoader;
 
   return kTRUE;
@@ -754,6 +954,11 @@ Bool_t AliSimulation::RunDigitization(const char* detectors,
 
   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;
@@ -815,6 +1020,11 @@ Bool_t AliSimulation::RunHitsDigitization(const char* detectors)
 
   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;
 
@@ -845,7 +1055,8 @@ Bool_t AliSimulation::RunHitsDigitization(const char* detectors)
 //_____________________________________________________________________________
 Bool_t AliSimulation::WriteRawData(const char* detectors, 
 				   const char* fileName,
-				   Bool_t deleteIntermediateFiles)
+				   Bool_t deleteIntermediateFiles,
+				   Bool_t selrawdata)
 {
 // convert the digits to raw data
 // First DDL raw data files for the given detectors are created.
@@ -855,6 +1066,8 @@ Bool_t AliSimulation::WriteRawData(const char* detectors,
 // If the file name has the extension ".root", the DATE file is converted
 // to a root file.
 // If deleteIntermediateFiles is true, the DATE file is deleted afterwards.
+// 'selrawdata' flag can be used to enable writing of detectors raw data
+// accoring to the trigger cluster.
 
   AliCodeTimerAuto("")
 
@@ -866,7 +1079,12 @@ Bool_t AliSimulation::WriteRawData(const char* detectors,
   if (!dateFileName.IsNull()) {
     Bool_t rootOutput = dateFileName.EndsWith(".root");
     if (rootOutput) dateFileName += ".date";
-    if (!ConvertRawFilesToDate(dateFileName)) {
+    TString selDateFileName;
+    if (selrawdata) {
+      selDateFileName = "selected.";
+      selDateFileName+= dateFileName;
+    }
+    if (!ConvertRawFilesToDate(dateFileName,selDateFileName)) {
       if (fStopOnError) return kFALSE;
     }
     if (deleteIntermediateFiles) {
@@ -886,6 +1104,16 @@ Bool_t AliSimulation::WriteRawData(const char* detectors,
       if (deleteIntermediateFiles) {
 	gSystem->Unlink(dateFileName);
       }
+      if (selrawdata) {
+	TString selFileName = "selected.";
+	selFileName        += fileName;
+	if (!ConvertDateToRoot(selDateFileName, selFileName)) {
+	  if (fStopOnError) return kFALSE;
+	}
+	if (deleteIntermediateFiles) {
+	  gSystem->Unlink(selDateFileName);
+	}
+      }
     }
   }
 
@@ -943,9 +1171,12 @@ Bool_t AliSimulation::WriteRawFiles(const char* detectors)
 }
 
 //_____________________________________________________________________________
-Bool_t AliSimulation::ConvertRawFilesToDate(const char* dateFileName)
+Bool_t AliSimulation::ConvertRawFilesToDate(const char* dateFileName,
+					    const char* selDateFileName)
 {
 // convert raw data DDL files to a DATE file with the program "dateStream"
+// The second argument is not empty when the user decides to write
+// the detectors raw data according to the trigger cluster.
 
   AliCodeTimerAuto("")
   
@@ -961,18 +1192,35 @@ Bool_t AliSimulation::ConvertRawFilesToDate(const char* dateFileName)
   if (!runLoader) return kFALSE;
 
   AliInfo(Form("converting raw data DDL files to DATE file %s", dateFileName));
+  Bool_t selrawdata = kFALSE;
+  if (strcmp(selDateFileName,"") != 0) selrawdata = kTRUE;
+
   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");
 
+  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) {
+      // Check if the event was triggered by CTP
+      runLoader->GetEvent(iEvent);
+      if (!runLoader->LoadTrigger()) {
+	AliCentralTrigger *aCTP = runLoader->GetTrigger();
+	if (aCTP->GetClassMask()) selEvents++;
+      }
+      else {
+	AliWarning("No trigger can be loaded! Writing of selected raw data is abandoned !");
+	selrawdata = kFALSE;
+      }
+    }
+
     // loop over detectors and DDLs
     for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
       for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls(iDet); iDDL++) {
@@ -1004,8 +1252,70 @@ Bool_t AliSimulation::ConvertRawFilesToDate(const char* dateFileName)
 
   Int_t result = gSystem->ClosePipe(pipe);
 
+  if (!(selrawdata && selEvents > 0)) {
+    delete runLoader;
+    return (result == 0);
+  }
+
+  AliInfo(Form("converting selected by trigger cluster raw data DDL files to DATE file %s", selDateFileName));
+  
+  sprintf(command, "dateStream -c -s -D -o %s -# %d -C -run %d", 
+	  selDateFileName,selEvents,runLoader->GetHeader()->GetRun());
+  FILE* pipe2 = gSystem->OpenPipe(command, "w");
+
+  for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
+
+    // Get the trigger decision and cluster
+    TString detClust;
+    runLoader->GetEvent(iEvent);
+    if (!runLoader->LoadTrigger()) {
+      AliCentralTrigger *aCTP = runLoader->GetTrigger();
+      if (aCTP->GetClassMask() == 0) continue;
+      detClust = aCTP->GetTriggeredDetectors();
+      AliInfo(Form("List of detectors to be read out: %s",detClust.Data()));
+    }
+
+    fprintf(pipe2, "GDC\n");
+    Float_t ldc = 0;
+    Int_t prevLDC = -1;
+
+    // loop over detectors and DDLs
+    for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
+      // Write only raw data from detectors that
+      // are contained in the trigger cluster(s)
+      if (!IsSelected(AliDAQ::DetectorName(iDet),detClust)) continue;
+
+      for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls(iDet); iDDL++) {
+
+        Int_t ddlID = AliDAQ::DdlID(iDet,iDDL);
+        Int_t ldcID = Int_t(ldc + 0.0001);
+        ldc += AliDAQ::NumberOfLdcs(iDet) / AliDAQ::NumberOfDdls(iDet);
+
+        char rawFileName[256];
+        sprintf(rawFileName, "raw%d/%s", 
+                iEvent, AliDAQ::DdlFileName(iDet,iDDL));
+
+	// check existence and size of raw data file
+        FILE* file = fopen(rawFileName, "rb");
+        if (!file) continue;
+        fseek(file, 0, SEEK_END);
+        unsigned long size = ftell(file);
+	fclose(file);
+        if (!size) continue;
+
+        if (ldcID != prevLDC) {
+          fprintf(pipe2, " LDC Id %d\n", ldcID);
+          prevLDC = ldcID;
+        }
+        fprintf(pipe2, "  Equipment Id %d Payload %s\n", ddlID, rawFileName);
+      }
+    }
+  }
+
+  Int_t result2 = gSystem->ClosePipe(pipe2);
+
   delete runLoader;
-  return (result == 0);
+  return ((result == 0) && (result2 == 0));
 }
 
 //_____________________________________________________________________________
@@ -1076,6 +1386,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", 
@@ -1170,6 +1481,7 @@ Bool_t AliSimulation::IsSelected(TString detName, TString& detectors) const
   return result;
 }
 
+//_____________________________________________________________________________
 Bool_t AliSimulation::ConvertRaw2SDigits(const char* rawDirectory, const char* esdFileName) 
 {
 //
@@ -1192,9 +1504,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;
     //
@@ -1253,6 +1565,7 @@ Bool_t AliSimulation::ConvertRaw2SDigits(const char* rawDirectory, const char* e
 	    }
 	} // detectors
 
+
 	//
 	//  If ESD information available obtain reconstructed vertex and store in header.
 	if (esdOK) {
@@ -1285,3 +1598,180 @@ 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
+  TString options;
+  if (fRunHLT.CompareTo("default")!=0) options=fRunHLT;
+  if (!IsSelected("HLT", fWriteRawData)) {
+    options+=" writerawfiles=";
+  } else {
+    options+=" writerawfiles=HLT";
+  }
+  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));
+  } 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()) ;
+
+	TString detectorsw("") ;  
+	Bool_t rv = kTRUE ; 
+	detectorsw =  qas.Run("ALL", AliQA::kHITS) ; 
+//	qas.Reset() ; 
+	detectorsw += qas.Run(fMakeSDigits.Data(), AliQA::kSDIGITS) ;   
+//	qas.Reset() ; 
+	detectorsw += qas.Run(fMakeDigits.Data(), AliQA::kDIGITS) ; 	
+//	qas.Reset() ; 
+	detectorsw += qas.Run(fMakeDigitsFromHits.Data(), AliQA::kDIGITS) ; 
+	
+	if ( detectorsw.IsNull() ) 
+		rv = kFALSE ; 
+	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)); 
+}