X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=STEER%2FAliSimulation.cxx;h=0ca530ad38e63e8d03f00d6c280756acbae68e45;hb=2cca49c62be903c247b610f569b472e1d85d521d;hp=26ec3ce5553d15c0d65cab2308def6ae54b0874b;hpb=b17cac0f0c50155e5f5d859dc2d2d8e20252c917;p=u%2Fmrichter%2FAliRoot.git diff --git a/STEER/AliSimulation.cxx b/STEER/AliSimulation.cxx index 26ec3ce5553..0ca530ad38e 100644 --- a/STEER/AliSimulation.cxx +++ b/STEER/AliSimulation.cxx @@ -105,32 +105,53 @@ // // /////////////////////////////////////////////////////////////////////////////// +#include +#include #include #include #include - -#include "AliLog.h" +#include + +#include "AliCDBStorage.h" +#include "AliCDBEntry.h" +#include "AliCDBManager.h" +#include "AliGeomManager.h" +#include "AliAlignObj.h" +#include "AliCentralTrigger.h" +#include "AliDAQ.h" #include "AliDigitizer.h" #include "AliGenerator.h" +#include "AliLog.h" #include "AliModule.h" #include "AliRun.h" #include "AliRunDigitizer.h" #include "AliRunLoader.h" #include "AliSimulation.h" #include "AliVertexGenFile.h" +#include "AliCentralTrigger.h" +#include "AliCTPRawData.h" +#include "AliRawReaderFile.h" +#include "AliESD.h" +#include "AliHeader.h" +#include "AliGenEventHeader.h" +#include "AliMC.h" ClassImp(AliSimulation) +AliSimulation *AliSimulation::fgInstance = 0; //_____________________________________________________________________________ -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), + fLoadAlObjsListOfDets("ALL"), fMakeSDigits("ALL"), fMakeDigits("ALL"), + fMakeTrigger(""), fMakeDigitsFromHits(""), fWriteRawData(""), fRawDataFileName(""), @@ -142,11 +163,15 @@ AliSimulation::AliSimulation(const char* configFileName, fGAliceFileName("galice.root"), fEventsPerFile(), fBkgrdFileNames(NULL), + fAlignObjArray(NULL), fUseBkgrdVertex(kTRUE), - fRegionOfInterest(kFALSE) + fRegionOfInterest(kFALSE), + fCDBUri(cdbUri), + fSpecCDBUri(), + fEmbeddingFlag(kFALSE) { // create simulation object with default parameters - + fgInstance = this; SetGAliceFile("galice.root"); } @@ -156,8 +181,11 @@ AliSimulation::AliSimulation(const AliSimulation& sim) : fRunGeneration(sim.fRunGeneration), fRunSimulation(sim.fRunSimulation), + fLoadAlignFromCDB(sim.fLoadAlignFromCDB), + fLoadAlObjsListOfDets(sim.fLoadAlObjsListOfDets), fMakeSDigits(sim.fMakeSDigits), fMakeDigits(sim.fMakeDigits), + fMakeTrigger(sim.fMakeTrigger), fMakeDigitsFromHits(sim.fMakeDigitsFromHits), fWriteRawData(sim.fWriteRawData), fRawDataFileName(""), @@ -169,8 +197,12 @@ AliSimulation::AliSimulation(const AliSimulation& sim) : fGAliceFileName(sim.fGAliceFileName), fEventsPerFile(), fBkgrdFileNames(NULL), + fAlignObjArray(NULL), fUseBkgrdVertex(sim.fUseBkgrdVertex), - fRegionOfInterest(sim.fRegionOfInterest) + fRegionOfInterest(sim.fRegionOfInterest), + fCDBUri(sim.fCDBUri), + fSpecCDBUri(), + fEmbeddingFlag(sim.fEmbeddingFlag) { // copy constructor @@ -184,6 +216,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()); + } + fgInstance = this; } //_____________________________________________________________________________ @@ -202,11 +239,16 @@ AliSimulation::~AliSimulation() // clean up fEventsPerFile.Delete(); +// if(fAlignObjArray) fAlignObjArray->Delete(); // fAlignObjArray->RemoveAll() ??? +// delete fAlignObjArray; fAlignObjArray=0; if (fBkgrdFileNames) { fBkgrdFileNames->Delete(); delete fBkgrdFileNames; } + + fSpecCDBUri.Delete(); + if (fgInstance==this) fgInstance = 0; } @@ -218,6 +260,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) { @@ -255,6 +358,99 @@ void AliSimulation::SetEventsPerFile(const char* detector, const char* type, fEventsPerFile.Add(obj); } +//_____________________________________________________________________________ +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. + + if (!gGeoManager || !gGeoManager->IsClosed()) { + AliError("Can't apply the misalignment! gGeoManager doesn't exist or it is still opened!"); + return kFALSE; + } + Bool_t delRunLoader = kFALSE; + if (!runLoader) { + runLoader = LoadRun("READ"); + if (!runLoader) return kFALSE; + delRunLoader = kTRUE; + } + + // Export ideal geometry + gGeoManager->Export("geometry.root"); + + // Load alignment data from CDB and apply to geometry through AliGeomManager + if(fLoadAlignFromCDB){ + + TString detStr = fLoadAlObjsListOfDets; + TString loadAlObjsListOfDets = ""; + + 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)) { + //add det to list of dets to be aligned from CDB + loadAlObjsListOfDets += det->GetName(); + loadAlObjsListOfDets += " "; + } + } // end loop over detectors + 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 (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; + } + } + } + + // Update the internal geometry of modules (ITS needs it) + TString detStr = fLoadAlObjsListOfDets; + 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; + + 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) { @@ -266,12 +462,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 @@ -279,6 +483,17 @@ 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; + + // If RunSimulation was not called, load the geometry and misalign it + if (!gGeoManager) { + AliGeomManager::LoadGeometry("geometry.root"); + if (!gGeoManager) if (fStopOnError) return kFALSE; + // Initialize the geometry manager (if not already done) + if(!MisalignGeometry()) if (fStopOnError) return kFALSE; + } + // hits -> summable digits if (!fMakeSDigits.IsNull()) { if (!RunSDigitization(fMakeSDigits)) if (fStopOnError) return kFALSE; @@ -304,6 +519,11 @@ Bool_t AliSimulation::Run(Int_t nEvents) } } + // digits -> trigger + if (!RunTrigger(fMakeTrigger)) { + if (fStopOnError) return kFALSE; + } + // digits -> raw data if (!fWriteRawData.IsNull()) { if (!WriteRawData(fWriteRawData, fRawDataFileName, @@ -315,6 +535,61 @@ Bool_t AliSimulation::Run(Int_t nEvents) return kTRUE; } +//_____________________________________________________________________________ +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; + + 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 + aCTP->LoadDescriptor( des ); + + // digits -> trigger + if( !aCTP->RunTrigger( runLoader ) ) { + if (fStopOnError) { + // delete aCTP; + return kFALSE; + } + } + + AliInfo(Form("Execution time: R:%.2fs C:%.2fs", + stopwatch.RealTime(),stopwatch.CpuTime())); + + delete runLoader; + + return kTRUE; +} + +//_____________________________________________________________________________ +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) { @@ -337,13 +612,40 @@ Bool_t AliSimulation::RunSimulation(Int_t nEvents) StdoutToAliInfo(StderrToAliError( gAlice->Init(fConfigFileName.Data()); );); + + // 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()); + + // Set run number in CDBManager + 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()); + + // Misalign geometry +#if ROOT_VERSION_CODE < 331527 + MisalignGeometry(runLoader); +#endif + +// 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. " @@ -467,6 +769,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*) @@ -486,6 +789,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; @@ -638,6 +942,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", @@ -655,24 +962,6 @@ Bool_t AliSimulation::ConvertRawFilesToDate(const char* dateFileName) { // convert raw data DDL files to a DATE file with the program "dateStream" - // DATE setup - const Int_t kNDetectors = 17; - const char* kDetectors[kNDetectors] = {"TPC", "ITSSPD", "ITSSDD", "ITSSSD", - "TRD", "TOF", "PHOS", "RICH", - "EMCAL", "MUON", "MUTR", "ZDC", - "PMD", "START", "VZERO", "CRT", - "FMD"}; - const Int_t kDetectorDDLs[kNDetectors] = {216, 20, 12, 16, - 18, 72, 20, 20, - 22, 20, 2, 1, - 6, 1, 1, 1, - 3}; - const Float_t kDetectorLDCs[kNDetectors] = {46, 2, 2, 1, - 4, 2, 1, 2, - 1, 2, 1, 1, - 1, 0.5, 0.5, 1, - 1}; - char* path = gSystem->Which(gSystem->Getenv("PATH"), "dateStream"); if (!path) { AliError("the program dateStream was not found"); @@ -686,7 +975,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"); @@ -696,16 +987,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"); @@ -737,10 +1028,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) { @@ -753,20 +1044,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); } @@ -807,8 +1110,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; } @@ -818,12 +1122,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) { @@ -878,3 +1182,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; +}