X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=STEER%2FAliSimulation.cxx;h=2cc0e1f1fd53b655c53023d952a8541f9dd50660;hb=dc3719f36554a2e7ab07cf6bdc56335838f1eee6;hp=1541807b308b605a200366aebb391810a9a22a98;hpb=591f51bb3032312d9ad393b38b5f055c365b5134;p=u%2Fmrichter%2FAliRoot.git diff --git a/STEER/AliSimulation.cxx b/STEER/AliSimulation.cxx index 1541807b308..2cc0e1f1fd5 100644 --- a/STEER/AliSimulation.cxx +++ b/STEER/AliSimulation.cxx @@ -105,32 +105,49 @@ // // /////////////////////////////////////////////////////////////////////////////// +#include #include #include #include - -#include "AliLog.h" +#include + +#include "AliCDBStorage.h" +#include "AliCDBEntry.h" +#include "AliCDBManager.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" 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(""), fMakeDigitsFromHits(""), fWriteRawData(""), fRawDataFileName(""), @@ -142,8 +159,12 @@ 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 @@ -156,8 +177,11 @@ 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), fMakeDigitsFromHits(sim.fMakeDigitsFromHits), fWriteRawData(sim.fWriteRawData), fRawDataFileName(""), @@ -169,8 +193,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 +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()); + } + } //_____________________________________________________________________________ @@ -202,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(); } @@ -218,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) { @@ -255,6 +353,261 @@ void AliSimulation::SetEventsPerFile(const char* detector, const char* type, fEventsPerFile.Add(obj); } +//_____________________________________________________________________________ +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; jUncheckedAt(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 + // them to the TGeo geometry passed as argument + // + + TFile* inFile = TFile::Open(fileName,"READ"); + if (!inFile || !inFile->IsOpen()) { + AliErrorClass(Form("Could not open file %s !",fileName)); + return kFALSE; + } + + TClonesArray* alObjArray = ((TClonesArray*) inFile->Get(clArrayName)); + inFile->Close(); + if (!alObjArray) { + AliErrorClass(Form("Could not get array (%s) from file (%s) !",clArrayName,fileName)); + return kFALSE; + } + + return ApplyAlignObjsToGeom(alObjArray); + +} + +//_____________________________________________________________________________ +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 + // param (to get the AliCDBStorage) and Id; apply the alignment objects + // to the TGeo geometry passed as argument + // + + AliCDBStorage* storage = AliCDBManager::Instance()->GetStorage(param); + AliCDBEntry* entry = storage->Get(Id); + TClonesArray* AlObjArray = ((TClonesArray*) entry->GetObject()); + + return ApplyAlignObjsToGeom(AlObjArray); + +} + +//_____________________________________________________________________________ +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 + // param (to get the AliCDBStorage) and Id; apply the alignment objects + // to the TGeo geometry passed as argument + // + + AliCDBParam* param = AliCDBManager::Instance()->CreateParameter(uri); + AliCDBId id(path, runnum, runnum, version, sversion); + + 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) { @@ -266,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 @@ -279,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; @@ -304,6 +675,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 +691,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 +768,49 @@ 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 + 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. " @@ -403,8 +870,8 @@ Bool_t AliSimulation::RunSimulation(Int_t nEvents) delete runLoader; - AliInfo("execution time:"); - StdoutToAliInfo(stopwatch.Print();); + AliInfo(Form("Execution time: R:%.2fs C:%.2fs", + stopwatch.RealTime(),stopwatch.CpuTime())); return kTRUE; } @@ -430,8 +897,8 @@ Bool_t AliSimulation::RunSDigitization(const char* detectors) TStopwatch stopwatchDet; stopwatchDet.Start(); det->Hits2SDigits(); - AliInfo(Form("execution time for %s:", det->GetName())); - StdoutToAliInfo(stopwatchDet.Print();); + AliInfo(Form("Execution time for %s: R:%.2fs C:%.2fs", + det->GetName(),stopwatchDet.RealTime(),stopwatchDet.CpuTime())); } } @@ -443,8 +910,8 @@ Bool_t AliSimulation::RunSDigitization(const char* detectors) delete runLoader; - AliInfo("execution time:"); - StdoutToAliInfo(stopwatch.Print();); + AliInfo(Form("Execution time: R:%.2fs C:%.2fs", + stopwatch.RealTime(),stopwatch.CpuTime())); return kTRUE; } @@ -467,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*) @@ -486,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; @@ -508,9 +977,9 @@ Bool_t AliSimulation::RunDigitization(const char* detectors, delete manager; - AliInfo("execution time:"); - StdoutToAliInfo(stopwatch.Print();); - + AliInfo(Form("Execution time: R:%.2fs C:%.2fs", + stopwatch.RealTime(),stopwatch.CpuTime())); + return kTRUE; } @@ -542,12 +1011,12 @@ Bool_t AliSimulation::RunHitsDigitization(const char* detectors) if (fStopOnError) return kFALSE; } - //PH delete runLoader; + delete runLoader; //PH Temporary fix to avoid interference with the PHOS loder/getter //PH The problem has to be solved in more general way 09/06/05 - AliInfo("execution time:"); - StdoutToAliInfo(stopwatch.Print();); + AliInfo(Form("Execution time: R:%.2fs C:%.2fs", + stopwatch.RealTime(),stopwatch.CpuTime())); return kTRUE; } @@ -600,8 +1069,8 @@ Bool_t AliSimulation::WriteRawData(const char* detectors, } } - AliInfo("execution time:"); - StdoutToAliInfo(stopwatch.Print();); + AliInfo(Form("Execution time: R:%.2fs C:%.2fs", + stopwatch.RealTime(),stopwatch.CpuTime())); return kTRUE; } @@ -638,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", @@ -655,24 +1127,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 +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"); @@ -696,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"); @@ -737,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) { @@ -753,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); } @@ -807,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; } @@ -818,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) { @@ -878,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; +}