X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=STEER%2FAliSimulation.cxx;h=2cc0e1f1fd53b655c53023d952a8541f9dd50660;hb=93e1dfe14ec401318039d5650efe552f2d997c55;hp=24a66c7def401c6bc0457ec99a82ee051b5c8d64;hpb=bfbd5665ee83ec5e12fe28ed27bff3182595f115;p=u%2Fmrichter%2FAliRoot.git

diff --git a/STEER/AliSimulation.cxx b/STEER/AliSimulation.cxx
index 24a66c7def4..2cc0e1f1fd5 100644
--- a/STEER/AliSimulation.cxx
+++ b/STEER/AliSimulation.cxx
@@ -116,7 +116,7 @@
 #include "AliCDBManager.h"
 #include "AliAlignObj.h"
 #include "AliCentralTrigger.h"
-#include "AliDAQConfig.h"
+#include "AliDAQ.h"
 #include "AliDigitizer.h"
 #include "AliGenerator.h"
 #include "AliLog.h"
@@ -127,17 +127,24 @@
 #include "AliSimulation.h"
 #include "AliVertexGenFile.h"
 #include "AliCentralTrigger.h"
+#include "AliCTPRawData.h"
+#include "AliRawReaderFile.h"
+#include "AliESD.h"
+#include "AliHeader.h"
+#include "AliGenEventHeader.h"
 
 ClassImp(AliSimulation)
 
 
 //_____________________________________________________________________________
-AliSimulation::AliSimulation(const char* configFileName,
+AliSimulation::AliSimulation(const char* configFileName, const char* cdbUri,
 			     const char* name, const char* title) :
   TNamed(name, title),
 
   fRunGeneration(kTRUE),
   fRunSimulation(kTRUE),
+  fLoadAlignFromCDB(kTRUE),
+  fLoadAlignData("ALL"),
   fMakeSDigits("ALL"),
   fMakeDigits("ALL"),
   fMakeTrigger(""),
@@ -154,7 +161,10 @@ AliSimulation::AliSimulation(const char* configFileName,
   fBkgrdFileNames(NULL),
   fAlignObjArray(NULL),
   fUseBkgrdVertex(kTRUE),
-  fRegionOfInterest(kFALSE)
+  fRegionOfInterest(kFALSE),
+  fCDBUri(cdbUri),
+  fSpecCDBUri(),
+  fEmbeddingFlag(kFALSE)
 {
 // create simulation object with default parameters
 
@@ -167,6 +177,8 @@ AliSimulation::AliSimulation(const AliSimulation& sim) :
 
   fRunGeneration(sim.fRunGeneration),
   fRunSimulation(sim.fRunSimulation),
+  fLoadAlignFromCDB(sim.fLoadAlignFromCDB),
+  fLoadAlignData(sim.fLoadAlignData),
   fMakeSDigits(sim.fMakeSDigits),
   fMakeDigits(sim.fMakeDigits),
   fMakeTrigger(sim.fMakeTrigger),
@@ -183,7 +195,10 @@ AliSimulation::AliSimulation(const AliSimulation& sim) :
   fBkgrdFileNames(NULL),
   fAlignObjArray(NULL),
   fUseBkgrdVertex(sim.fUseBkgrdVertex),
-  fRegionOfInterest(sim.fRegionOfInterest)
+  fRegionOfInterest(sim.fRegionOfInterest),
+  fCDBUri(sim.fCDBUri),
+  fSpecCDBUri(),
+  fEmbeddingFlag(sim.fEmbeddingFlag)
 {
 // copy constructor
 
@@ -197,6 +212,11 @@ AliSimulation::AliSimulation(const AliSimulation& sim) :
     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());
+  }
+
 }
 
 //_____________________________________________________________________________
@@ -215,11 +235,15 @@ AliSimulation::~AliSimulation()
 // clean up
 
   fEventsPerFile.Delete();
+//  if(fAlignObjArray) fAlignObjArray->Delete(); // fAlignObjArray->RemoveAll() ???
+//  delete fAlignObjArray; fAlignObjArray=0;
 
   if (fBkgrdFileNames) {
     fBkgrdFileNames->Delete();
     delete fBkgrdFileNames;
   }
+
+  fSpecCDBUri.Delete();
 }
 
 
@@ -231,6 +255,67 @@ void AliSimulation::SetNumberOfEvents(Int_t nEvents)
   fNEvents = nEvents;
 }
 
+//_____________________________________________________________________________
+void AliSimulation::InitCDBStorage()
+{
+// 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
+
+  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("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+    fCDBUri = "";
+  }
+  else {
+    AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+    AliDebug(2, Form("Default CDB storage is set to: %s",fCDBUri.Data()));
+    AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+    man->SetDefaultStorage(fCDBUri);
+  }
+
+  // Now activate the detector specific CDB storage locations
+  for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
+    TObject* obj = fSpecCDBUri[i];
+    if (!obj) continue;
+    AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+    AliDebug(2, Form("Specific CDB storage for %s is set to: %s",obj->GetName(),obj->GetTitle()));
+    AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+    man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
+  }
+  man->Print();
+}
+
+//_____________________________________________________________________________
+void AliSimulation::SetDefaultStorage(const char* uri) {
+// Store the desired default CDB storage location
+// Activate it later within the Run() method
+
+  fCDBUri = uri;
+
+}
+
+//_____________________________________________________________________________
+void AliSimulation::SetSpecificStorage(const char* calibType, const char* uri) {
+// Store a detector-specific CDB storage location
+// Activate it later within the Run() method
+
+  AliCDBPath aPath(calibType);
+  if(!aPath.IsValid()){
+  	AliError(Form("Not a valid path: %s", calibType));
+  	return;
+  }
+
+  TObject* obj = fSpecCDBUri.FindObject(calibType);
+  if (obj) fSpecCDBUri.Remove(obj);
+  fSpecCDBUri.Add(new TNamed(calibType, uri));
+
+}
+
 //_____________________________________________________________________________
 void AliSimulation::SetConfigFile(const char* fileName)
 {
@@ -269,7 +354,37 @@ void AliSimulation::SetEventsPerFile(const char* detector, const char* type,
 }
 
 //_____________________________________________________________________________
-Bool_t AliSimulation::ApplyDisplacements(const char* fileName, const char* clArrayName)
+Bool_t AliSimulation::ApplyAlignObjsToGeom(TObjArray* alObjArray)
+{
+  // Read collection of alignment objects (AliAlignObj derived) saved
+  // in the TClonesArray ClArrayName and apply them to the geometry
+  // manager singleton.
+  //
+  alObjArray->Sort();
+  Int_t nvols = alObjArray->GetEntriesFast();
+
+  Bool_t flag = kTRUE;
+
+  for(Int_t j=0; j<nvols; j++)
+    {
+      AliAlignObj* alobj = (AliAlignObj*) alObjArray->UncheckedAt(j);
+      if (alobj->ApplyToGeometry() == kFALSE) flag = kFALSE;
+    }
+
+  if (AliDebugLevelClass() >= 1) {
+    gGeoManager->GetTopNode()->CheckOverlaps(1);
+    TObjArray* ovexlist = gGeoManager->GetListOfOverlaps();
+    if(ovexlist->GetEntriesFast()){  
+      AliError("The application of alignment objects to the geometry caused huge overlaps/extrusions!");
+   }
+  }
+
+  return flag;
+
+}
+
+//_____________________________________________________________________________
+Bool_t AliSimulation::ApplyAlignObjsToGeom(const char* fileName, const char* clArrayName)
 {
   // read collection of alignment objects (AliAlignObj derived) saved
   // in the TClonesArray ClArrayName in the file fileName and apply
@@ -289,12 +404,12 @@ Bool_t AliSimulation::ApplyDisplacements(const char* fileName, const char* clArr
     return kFALSE;
   }
 
-  return gAlice->ApplyDisplacements(alObjArray);
+  return ApplyAlignObjsToGeom(alObjArray);
 
 }
 
 //_____________________________________________________________________________
-Bool_t AliSimulation::ApplyDisplacements(AliCDBParam* param, AliCDBId& Id)
+Bool_t AliSimulation::ApplyAlignObjsToGeom(AliCDBParam* param, AliCDBId& Id)
 {
   // read collection of alignment objects (AliAlignObj derived) saved
   // in the TClonesArray ClArrayName in the AliCDBEntry identified by
@@ -306,12 +421,12 @@ Bool_t AliSimulation::ApplyDisplacements(AliCDBParam* param, AliCDBId& Id)
   AliCDBEntry* entry = storage->Get(Id);
   TClonesArray* AlObjArray = ((TClonesArray*) entry->GetObject());
 
-  return gAlice->ApplyDisplacements(AlObjArray);
+  return ApplyAlignObjsToGeom(AlObjArray);
 
 }
 
 //_____________________________________________________________________________
-Bool_t AliSimulation::ApplyDisplacements(const char* uri, const char* path, Int_t runnum, Int_t version, Int_t sversion)
+Bool_t AliSimulation::ApplyAlignObjsToGeom(const char* uri, const char* path, Int_t runnum, Int_t version, Int_t sversion)
 {
   // read collection of alignment objects (AliAlignObj derived) saved
   // in the TClonesArray ClArrayName in the AliCDBEntry identified by
@@ -322,10 +437,177 @@ Bool_t AliSimulation::ApplyDisplacements(const char* uri, const char* path, Int_
   AliCDBParam* param = AliCDBManager::Instance()->CreateParameter(uri);
   AliCDBId id(path, runnum, runnum, version, sversion);
 
-  return ApplyDisplacements(param, id);
+  return ApplyAlignObjsToGeom(param, id);
 
 }
 
+//_____________________________________________________________________________
+Bool_t AliSimulation::ApplyAlignObjsToGeom(const char* detName, Int_t runnum, Int_t version, Int_t sversion)
+{
+  // read collection of alignment objects (AliAlignObj derived) saved
+  // in the TClonesArray ClArrayName in the AliCDBEntry identified by
+  // param (to get the AliCDBStorage) and Id; apply the alignment objects
+  // to the TGeo geometry passed as argument
+  //
+
+  AliCDBPath path(detName,"Align","Data");
+  AliCDBEntry* entry = AliCDBManager::Instance()->Get(path.GetPath(),runnum,version,sversion);
+
+  if(!entry) return kFALSE;
+  TClonesArray* AlObjArray = ((TClonesArray*) entry->GetObject());
+
+  return ApplyAlignObjsToGeom(AlObjArray);
+}
+
+//_____________________________________________________________________________
+Bool_t AliSimulation::SetAlignObjArraySingleDet(const char* detName)
+{
+  // Fills array of single detector's alignable objects from CDB
+  
+  AliDebug(2, Form("Loading alignment data for detector: %s",detName));
+  
+  AliCDBEntry *entry;
+  	
+  AliCDBPath path(detName,"Align","Data");
+	
+  entry=AliCDBManager::Instance()->Get(path.GetPath());
+  if(!entry){ 
+  	AliDebug(2,Form("Couldn't load alignment data for detector %s",detName));
+	return kFALSE;
+  }
+  entry->SetOwner(1);
+  TClonesArray *alignArray = (TClonesArray*) entry->GetObject();	
+  alignArray->SetOwner(0);
+  AliDebug(2,Form("Found %d alignment objects for %s",
+			alignArray->GetEntries(),detName));
+
+  AliAlignObj *alignObj=0;
+  TIter iter(alignArray);
+	
+  // loop over align objects in detector
+  while( ( alignObj=(AliAlignObj *) iter.Next() ) ){
+  	fAlignObjArray->Add(alignObj);
+  }
+  // delete entry --- Don't delete, it is cached!
+	
+  AliDebug(2, Form("fAlignObjArray entries: %d",fAlignObjArray->GetEntries() ));
+  return kTRUE;
+
+}
+
+//_____________________________________________________________________________
+Bool_t AliSimulation::MisalignGeometry(AliRunLoader *runLoader)
+{
+  // Read the alignment objects from CDB.
+  // Each detector is supposed to have the
+  // alignment objects in DET/Align/Data CDB path.
+  // All the detector objects are then collected,
+  // sorted by geometry level (starting from ALIC) and
+  // then applied to the TGeo geometry.
+  // Finally an overlaps check is performed.
+
+  Bool_t delRunLoader = kFALSE;
+  if (!runLoader) {
+    runLoader = LoadRun("READ");
+    if (!runLoader) return kFALSE;
+    delRunLoader = kTRUE;
+  }
+
+  // Load alignment data from CDB and fill fAlignObjArray 
+  if(fLoadAlignFromCDB){
+  	if(!fAlignObjArray) fAlignObjArray = new TObjArray();
+  	
+	//fAlignObjArray->RemoveAll(); 
+ 	fAlignObjArray->Clear();  	
+	fAlignObjArray->SetOwner(0);
+ 
+  	TString detStr = fLoadAlignData;
+  	TString dataNotLoaded="";
+  	TString dataLoaded="";
+  
+  	TObjArray* detArray = runLoader->GetAliRun()->Detectors();
+  	for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
+  		AliModule* det = (AliModule*) detArray->At(iDet);
+  		if (!det || !det->IsActive()) continue;
+  		if (IsSelected(det->GetName(), detStr)) {
+  			if(!SetAlignObjArraySingleDet(det->GetName())){
+  				dataNotLoaded += det->GetName();
+  				dataNotLoaded += " ";
+  			} else {
+				dataLoaded += det->GetName();
+				dataLoaded += " ";
+			}
+  		}
+  	} // end loop over detectors
+  
+  	if ((detStr.CompareTo("ALL") == 0)) detStr = "";
+  	dataNotLoaded += detStr;
+  	if(!dataLoaded.IsNull()) AliInfo(Form("Alignment data loaded for: %s",
+  			  dataLoaded.Data()));
+  	if(!dataNotLoaded.IsNull()) AliInfo(Form("Didn't/couldn't load alignment data for: %s",
+  			  dataNotLoaded.Data()));
+  } // fLoadAlignFromCDB flag
+ 
+  // 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 (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;
+    }
+  }
+
+
+  // Update the internal geometry of modules (ITS needs it)
+  TString detStr = fLoadAlignData;
+  TObjArray* detArray = runLoader->GetAliRun()->Detectors();
+  for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
+
+    AliModule* det = (AliModule*) detArray->At(iDet);
+    if (!det || !det->IsActive()) continue;
+    if (IsSelected(det->GetName(), detStr)) {
+      det->UpdateInternalGeometry();
+    }
+  } // end loop over detectors
+
+
+  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;
+}
+
 //_____________________________________________________________________________
 void AliSimulation::MergeWith(const char* fileName, Int_t nSignalPerBkgrd)
 {
@@ -337,12 +619,20 @@ void AliSimulation::MergeWith(const char* fileName, Int_t nSignalPerBkgrd)
   fBkgrdFileNames->Add(fileNameStr);
 }
 
+void AliSimulation::EmbedInto(const char* fileName, Int_t nSignalPerBkgrd)
+{
+// add a file with background events for embeddin
+  MergeWith(fileName, nSignalPerBkgrd);
+  fEmbeddingFlag = kTRUE;
+}
 
 //_____________________________________________________________________________
 Bool_t AliSimulation::Run(Int_t nEvents)
 {
 // run the generation, simulation and digitization
 
+  InitCDBStorage();
+
   if (nEvents > 0) fNEvents = nEvents;
 
   // generation and simulation -> hits
@@ -350,6 +640,16 @@ Bool_t AliSimulation::Run(Int_t nEvents)
     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;
+
+  // Load and misalign the geometry
+  if (!gGeoManager) {
+    TGeoManager::Import("geometry.root");
+    if (!gGeoManager) if (fStopOnError) return kFALSE;
+    if (!MisalignGeometry()) if (fStopOnError) return kFALSE;
+  }
+  
   // hits -> summable digits
   if (!fMakeSDigits.IsNull()) {
     if (!RunSDigitization(fMakeSDigits)) if (fStopOnError) return kFALSE;
@@ -376,10 +676,8 @@ Bool_t AliSimulation::Run(Int_t nEvents)
   }
 
   // digits -> trigger
-  if (!fMakeTrigger.IsNull()) {
-    if (!RunTrigger(fMakeTrigger)) {
-      if (fStopOnError) return kFALSE;
-    }
+  if (!RunTrigger(fMakeTrigger)) {
+    if (fStopOnError) return kFALSE;
   }
 
   // digits -> raw data
@@ -398,79 +696,56 @@ Bool_t AliSimulation::RunTrigger(const char* descriptors)
 {
   // run the trigger
 
-  TStopwatch stopwatch;
-  stopwatch.Start();
-
-  AliRunLoader* runLoader = LoadRun("READ");
-  if (!runLoader) return kFALSE;
-  TString des = descriptors;
+   TStopwatch stopwatch;
+   stopwatch.Start();
+
+   AliRunLoader* runLoader = LoadRun("READ");
+   if (!runLoader) return kFALSE;
+   TString des = descriptors;
+
+   if (des.IsNull()) {
+     if (gAlice->GetTriggerDescriptor() != "") {
+       des = gAlice->GetTriggerDescriptor();
+     }
+     else {
+       AliWarning("No trigger descriptor is specified. Skipping the trigger simulation...");
+       return kTRUE;
+     }
+   }
+
+   runLoader->MakeTree( "GG" );
+   AliCentralTrigger* aCTP = runLoader->GetTrigger();
   // Load Descriptors
-  AliCentralTrigger* aCTP = new AliCentralTrigger( des );
+   aCTP->LoadDescriptor( des );
 
   // digits -> trigger
-  if( !aCTP->RunTrigger( runLoader ) ) {
-    if (fStopOnError) {
-      delete aCTP;
-      return kFALSE;
-    }
-  }
-
-/*
-  // Process each event
-  for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
-    AliInfo(Form("processing event %d", iEvent));
-    runLoader->GetEvent(iEvent);
-
-    TObjArray* detArray = runLoader->GetAliRun()->Detectors();
-    for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
-      AliModule* det = (AliModule*) detArray->At(iDet);
-      if (!det || !det->IsActive()) continue;
-      if (IsSelected(det->GetName(), detStr)) {
-        AliInfo(Form("triggering from digits for %s", det->GetName()));
-
-     //   AliLoader* loader = fLoader[iDet];
-     //   loader->LoadDigits("read");
-     //   TTree* digitsTree = loader->TreeD();
-     //   det->Trigger( digitsTree );
-     // or
-        AliTriggerDetector* tdet = det->CreateTriggerDetector();
-        TObjArray* detInp = dtrg->GetTriggerInputs();
-        for( Int_t i=0; i<detInp->GetEntriesFast(); i++ )
-               fInputs.AddLast( detInp->At(i) );
-
-        AliInfo(Form("Execution time for %s: R:%.2fs C:%.2fs",
-                det->GetName(),stopwatchDet.RealTime(),stopwatchDet.CpuTime()));
-      }
-    }
-
-    if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
-      AliError(Form("the following detectors were not found: %s",
-                    detStr.Data()));
+   if( !aCTP->RunTrigger( runLoader ) ) {
       if (fStopOnError) {
-         delete centralTP;
+    //  delete aCTP;
          return kFALSE;
       }
-    }
-
-    // Check trigger conditions
-    centralTP->TriggerConditions();
+   }
 
-    // Write trigger ????
-    centralTP->Write();
+   AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
+           stopwatch.RealTime(),stopwatch.CpuTime()));
 
-  } */
+   delete runLoader;
 
-  AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
-               stopwatch.RealTime(),stopwatch.CpuTime()));
+   return kTRUE;
+}
 
-  delete aCTP;
-  delete runLoader;
+//_____________________________________________________________________________
+Bool_t AliSimulation::WriteTriggerRawData()
+{
+  // Writes the CTP (trigger) DDL raw data
+  // Details of the format are given in the
+  // trigger TDR - pages 134 and 135.
+  AliCTPRawData writer;
+  writer.RawData();
 
   return kTRUE;
 }
 
-
-
 //_____________________________________________________________________________
 Bool_t AliSimulation::RunSimulation(Int_t nEvents)
 {
@@ -494,32 +769,48 @@ Bool_t AliSimulation::RunSimulation(Int_t nEvents)
     gAlice->Init(fConfigFileName.Data());
   ););
 
-  // 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 (gAlice->ApplyDisplacements(fAlignObjArray) == kFALSE) {
-	AliError("The application of misalignment failed! Restart aliroot and try again. ");
-	return kFALSE;
-      }
-    }
-    else {
-      AliError("Can't apply the misalignment! gGeoManager doesn't exist or it is still opened!");
-      return kFALSE;
-    }
+  // Get the trigger descriptor string
+  // Either from AliSimulation or from
+  // gAlice
+  if (fMakeTrigger.IsNull()) {
+    if (gAlice->GetTriggerDescriptor() != "")
+      fMakeTrigger = gAlice->GetTriggerDescriptor();
   }
+  else
+    gAlice->SetTriggerDescriptor(fMakeTrigger.Data());
 
-  // Export TGeo geometry
-  if (gGeoManager) gGeoManager->Export("geometry.root");
+  // Set run number in CDBManager
+  AliCDBManager::Instance()->SetRun(gAlice->GetRunNumber());
+  AliInfo(Form("Run number: %d",AliCDBManager::Instance()->GetRun()));
 
   AliRunLoader* runLoader = gAlice->GetRunLoader();
   if (!runLoader) {
-    AliError(Form("gAlice has no run loader object. "
-                  "Check your config file: %s", fConfigFileName.Data()));
-    return kFALSE;
+             AliError(Form("gAlice has no run loader object. "
+        		     "Check your config file: %s", fConfigFileName.Data()));
+             return kFALSE;
   }
   SetGAliceFile(runLoader->GetFileName());
+ 
+  // Export ideal geometry 
+  if (gGeoManager) gGeoManager->Export("geometry.root");
+
+  // Misalign geometry
+//   if (!MisalignGeometry(runLoader)) {
+//     delete runLoader;
+//     return kFALSE;
+//   }
+  MisalignGeometry(runLoader);
+
+  // 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. "
+//                   "Check your config file: %s", fConfigFileName.Data()));
+//     return kFALSE;
+//   }
+//   SetGAliceFile(runLoader->GetFileName());
 
   if (!gAlice->Generator()) {
     AliError(Form("gAlice has no generator object. "
@@ -643,6 +934,7 @@ Bool_t AliSimulation::RunDigitization(const char* detectors,
   if (fBkgrdFileNames) nStreams = fBkgrdFileNames->GetEntriesFast() + 1;
   Int_t signalPerBkgrd = GetNSignalPerBkgrd();
   AliRunDigitizer* manager = new AliRunDigitizer(nStreams, signalPerBkgrd);
+  // manager->SetEmbeddingFlag(fEmbeddingFlag);
   manager->SetInputStream(0, fGAliceFileName.Data());
   for (Int_t iStream = 1; iStream < nStreams; iStream++) {
     const char* fileName = ((TObjString*)
@@ -662,6 +954,7 @@ Bool_t AliSimulation::RunDigitization(const char* detectors,
     if (IsSelected(det->GetName(), detStr) && 
 	!IsSelected(det->GetName(), detExcl)) {
       AliDigitizer* digitizer = det->CreateDigitizer(manager);
+      
       if (!digitizer) {
 	AliError(Form("no digitizer for %s", det->GetName()));
 	if (fStopOnError) return kFALSE;
@@ -814,6 +1107,9 @@ Bool_t AliSimulation::WriteRawFiles(const char* detectors)
       }
     }
 
+    if (!WriteTriggerRawData())
+      if (fStopOnError) return kFALSE;
+
     gSystem->ChangeDirectory(baseDir);
     if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
       AliError(Form("the following detectors were not found: %s", 
@@ -844,7 +1140,9 @@ Bool_t AliSimulation::ConvertRawFilesToDate(const char* dateFileName)
 
   AliInfo(Form("converting raw data DDL files to DATE file %s", dateFileName));
   char command[256];
-  sprintf(command, "dateStream -o %s -# %d -C", 
+  // 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());
   FILE* pipe = gSystem->OpenPipe(command, "w");
 
@@ -854,16 +1152,16 @@ Bool_t AliSimulation::ConvertRawFilesToDate(const char* dateFileName)
     Int_t prevLDC = -1;
 
     // loop over detectors and DDLs
-    for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
-      for (Int_t iDDL = 0; iDDL < kDetectorDDLs[iDet]; iDDL++) {
+    for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
+      for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls(iDet); iDDL++) {
 
-        Int_t ddlID = 0x100*iDet + iDDL;
+        Int_t ddlID = AliDAQ::DdlID(iDet,iDDL);
         Int_t ldcID = Int_t(ldc + 0.0001);
-        ldc += kDetectorLDCs[iDet] / kDetectorDDLs[iDet];
+        ldc += AliDAQ::NumberOfLdcs(iDet) / AliDAQ::NumberOfDdls(iDet);
 
         char rawFileName[256];
-        sprintf(rawFileName, "raw%d/%s_%d.ddl", 
-                iEvent, kDetectors[iDet], ddlID);
+        sprintf(rawFileName, "raw%d/%s", 
+                iEvent, AliDAQ::DdlFileName(iDet,iDDL));
 
 	// check existence and size of raw data file
         FILE* file = fopen(rawFileName, "rb");
@@ -895,10 +1193,10 @@ Bool_t AliSimulation::ConvertDateToRoot(const char* dateFileName,
 // convert a DATE file to a root file with the program "alimdc"
 
   // ALIMDC setup
-  const Int_t kDBSize = 1000000000;
+  const Int_t kDBSize = 2000000000;
   const Int_t kTagDBSize = 1000000000;
   const Bool_t kFilter = kFALSE;
-  const Int_t kCompression = 1;
+  const Int_t kCompression = 0;
 
   char* path = gSystem->Which(gSystem->Getenv("PATH"), "alimdc");
   if (!path) {
@@ -911,20 +1209,32 @@ Bool_t AliSimulation::ConvertDateToRoot(const char* dateFileName,
   AliInfo(Form("converting DATE file %s to root file %s", 
                dateFileName, rootFileName));
 
-  gSystem->Exec("rm -rf /tmp/mdc1");
-  gSystem->Exec("rm -rf /tmp/mdc2");
+  const char* rawDBFS[2] = { "/tmp/mdc1", "/tmp/mdc2" };
+  const char* tagDBFS    = "/tmp/mdc1/tags";
 
-  gSystem->Exec("mkdir /tmp/mdc1");
-  gSystem->Exec("mkdir /tmp/mdc2");
+  // User defined file system locations
+  if (gSystem->Getenv("ALIMDC_RAWDB1")) 
+    rawDBFS[0] = gSystem->Getenv("ALIMDC_RAWDB1");
+  if (gSystem->Getenv("ALIMDC_RAWDB2")) 
+    rawDBFS[1] = gSystem->Getenv("ALIMDC_RAWDB2");
+  if (gSystem->Getenv("ALIMDC_TAGDB")) 
+    tagDBFS = gSystem->Getenv("ALIMDC_TAGDB");
 
-  char command[256];
-  sprintf(command, "alimdc %d %d %d %d %s", 
-	  kDBSize, kTagDBSize, kFilter, kCompression, dateFileName);
-  Int_t result = gSystem->Exec(command);
-  sprintf(command, "mv /tmp/mdc1/*.root %s", rootFileName);
-  gSystem->Exec(command);
-  gSystem->Exec("rm -rf /tmp/mdc1");
-  gSystem->Exec("rm -rf /tmp/mdc2");
+  gSystem->Exec(Form("rm -rf %s",rawDBFS[0]));
+  gSystem->Exec(Form("rm -rf %s",rawDBFS[1]));
+  gSystem->Exec(Form("rm -rf %s",tagDBFS));
+
+  gSystem->Exec(Form("mkdir %s",rawDBFS[0]));
+  gSystem->Exec(Form("mkdir %s",rawDBFS[1]));
+  gSystem->Exec(Form("mkdir %s",tagDBFS));
+
+  Int_t result = gSystem->Exec(Form("alimdc %d %d %d %d %s", 
+				    kDBSize, kTagDBSize, kFilter, kCompression, dateFileName));
+  gSystem->Exec(Form("mv %s/*.root %s", rawDBFS[0], rootFileName));
+
+  gSystem->Exec(Form("rm -rf %s",rawDBFS[0]));
+  gSystem->Exec(Form("rm -rf %s",rawDBFS[1]));
+  gSystem->Exec(Form("rm -rf %s",tagDBFS));
 
   return (result == 0);
 }
@@ -965,8 +1275,9 @@ Int_t AliSimulation::GetNSignalPerBkgrd(Int_t nEvents) const
   // get the number of signal events
   if (nEvents <= 0) {
     AliRunLoader* runLoader = 
-      AliRunLoader::Open(fGAliceFileName.Data(), "SIGNAL");
+	AliRunLoader::Open(fGAliceFileName.Data(), "SIGNAL");
     if (!runLoader) return 1;
+    
     nEvents = runLoader->GetNumberOfEvents();
     delete runLoader;
   }
@@ -976,12 +1287,12 @@ Int_t AliSimulation::GetNSignalPerBkgrd(Int_t nEvents) const
     // get the number of background events
     const char* fileName = ((TObjString*)
 			    (fBkgrdFileNames->At(iBkgrdFile)))->GetName();
-    AliRunLoader* runLoader = 
+    AliRunLoader* runLoader =
       AliRunLoader::Open(fileName, "BKGRD");
     if (!runLoader) continue;
     Int_t nBkgrdEvents = runLoader->GetNumberOfEvents();
     delete runLoader;
-
+  
     // get or calculate the number of signal per background events
     Int_t nSignalPerBkgrd = fBkgrdFileNames->At(iBkgrdFile)->GetUniqueID();
     if (nSignalPerBkgrd <= 0) {
@@ -1036,3 +1347,104 @@ Bool_t AliSimulation::IsSelected(TString detName, TString& detectors) const
 
   return result;
 }
+
+Bool_t AliSimulation::ConvertRaw2SDigits(const char* rawDirectory, const char* esdFileName) 
+{
+//
+// Steering routine  to convert raw data in directory rawDirectory/ to fake SDigits. 
+// These can be used for embedding of MC tracks into RAW data using the standard 
+// merging procedure.
+//
+// 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;
+    }
+    
+    AliInfo(Form("initializing gAlice with config file %s",fConfigFileName.Data()));
+    StdoutToAliInfo(StderrToAliError(gAlice->Init(fConfigFileName.Data());););
+//
+//  Initialize CDB     
+    InitCDBStorage();
+    AliCDBManager* man = AliCDBManager::Instance();
+    man->SetRun(0); // Should this come from rawdata header ?
+    
+    Int_t iDet;
+    //
+    // Get the runloader
+    AliRunLoader* runLoader = gAlice->GetRunLoader();
+    //
+    // Open esd file if available
+    TFile* esdFile = TFile::Open(esdFileName);
+    Bool_t esdOK = (esdFile != 0);
+    AliESD* esd = new AliESD;
+    TTree* treeESD = 0;
+    if (esdOK) {
+	treeESD = (TTree*) esdFile->Get("esdTree");
+	if (!treeESD) {
+	    AliWarning("No ESD tree found");
+	    esdOK = kFALSE;
+	} else {
+	    treeESD->SetBranchAddress("ESD", &esd);
+	}
+    }
+    //
+    // Create the RawReader
+    AliRawReaderFile* rawReader = new AliRawReaderFile(rawDirectory);
+    //
+    // Get list of detectors
+    TObjArray* detArray = runLoader->GetAliRun()->Detectors();
+    //
+    // Get Header
+    AliHeader* header = runLoader->GetHeader();
+    //
+    // Event loop
+    Int_t nev = 0;
+    while(kTRUE) {
+	if (!(rawReader->NextEvent())) break;
+	//
+	// 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();
+	} // detectors
+
+	//
+	//  If ESD information available obtain reconstructed vertex and store in header.
+	if (esdOK) {
+	    treeESD->GetEvent(nev);
+	    const AliESDVertex* esdVertex = esd->GetPrimaryVertex();
+	    Double_t position[3];
+	    esdVertex->GetXYZ(position);
+	    AliGenEventHeader* mcHeader = new  AliGenEventHeader("ESD");
+	    TArrayF mcV;
+	    mcV.Set(3);
+	    for (Int_t i = 0; i < 3; i++) mcV[i] = position[i];
+	    mcHeader->SetPrimaryVertex(mcV);
+	    header->Reset(0,nev);
+	    header->SetGenEventHeader(mcHeader);
+	    printf("***** Saved vertex %f %f %f \n", position[0], position[1], position[2]);
+	}
+	nev++;
+//
+//      Finish the event
+	runLoader->TreeE()->Fill();
+	runLoader->SetNextEvent();
+    } // events
+ 
+    delete rawReader;
+//
+//  Finish the run 
+    runLoader->CdGAFile();
+    runLoader->WriteHeader("OVERWRITE");
+    runLoader->WriteRunLoader();
+
+    return kTRUE;
+}