// //
// sim.SetWriteRawData("MUON"); // write raw data for MUON //
// //
+// The default output format of the raw data are DDL files. They are //
+// converted to a DATE file, if a file name is given as second argument. //
+// For this conversion the program "dateStream" is required. If the file //
+// name has the extension ".root", the DATE file is converted to a root //
+// file. The program "alimdc" is used for this purpose. For the conversion //
+// to DATE and root format the two conversion programs have to be installed. //
+// Only the raw data in the final format is kept if the third argument is //
+// kTRUE. //
+// //
// The methods RunSimulation, RunSDigitization, RunDigitization, //
// RunHitsDigitization and WriteRawData can be used to run only parts of //
-// the full simulation chain. //
+// the full simulation chain. The creation of raw data DDL files and their //
+// conversion to the DATE or root format can be run directly by calling //
+// the methods WriteRawFiles, ConvertRawFilesToDate and ConvertDateToRoot. //
+// //
+// The default number of events per file, which is usually set in the //
+// config file, can be changed for individual detectors and data types //
+// by calling //
+// //
+// sim.SetEventsPerFile("PHOS", "Reconstructed Points", 3); //
+// //
+// The first argument is the detector, the second one the data type and the //
+// last one the number of events per file. Valid data types are "Hits", //
+// "Summable Digits", "Digits", "Reconstructed Points" and "Tracks". //
+// The number of events per file has to be set before the simulation of //
+// hits. Otherwise it has no effect. //
// //
///////////////////////////////////////////////////////////////////////////////
+#include <TGeoManager.h>
#include <TObjString.h>
#include <TStopwatch.h>
#include <TSystem.h>
-
+#include <TFile.h>
+
+#include "AliCDBStorage.h"
+#include "AliCDBEntry.h"
+#include "AliCDBManager.h"
+#include "AliAlignObj.h"
+#include "AliCentralTrigger.h"
+#include "AliDAQConfig.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"
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(""),
+ fDeleteIntermediateFiles(kFALSE),
fStopOnError(kFALSE),
fNEvents(1),
fConfigFileName(configFileName),
fGAliceFileName("galice.root"),
+ fEventsPerFile(),
fBkgrdFileNames(NULL),
+ fAlignObjArray(NULL),
fUseBkgrdVertex(kTRUE),
- fRegionOfInterest(kTRUE)
+ fRegionOfInterest(kFALSE),
+ fCDBUri(cdbUri)
{
// create simulation object with default parameters
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(""),
+ fDeleteIntermediateFiles(kFALSE),
fStopOnError(sim.fStopOnError),
fNEvents(sim.fNEvents),
fConfigFileName(sim.fConfigFileName),
fGAliceFileName(sim.fGAliceFileName),
+ fEventsPerFile(),
fBkgrdFileNames(NULL),
+ fAlignObjArray(NULL),
fUseBkgrdVertex(sim.fUseBkgrdVertex),
- fRegionOfInterest(sim.fRegionOfInterest)
+ fRegionOfInterest(sim.fRegionOfInterest),
+ fCDBUri(sim.fCDBUri)
{
// copy constructor
+ for (Int_t i = 0; i < sim.fEventsPerFile.GetEntriesFast(); i++) {
+ if (!sim.fEventsPerFile[i]) continue;
+ fEventsPerFile.Add(sim.fEventsPerFile[i]->Clone());
+ }
+
fBkgrdFileNames = new TObjArray;
for (Int_t i = 0; i < sim.fBkgrdFileNames->GetEntriesFast(); i++) {
if (!sim.fBkgrdFileNames->At(i)) continue;
{
// clean up
+ fEventsPerFile.Delete();
+// if(fAlignObjArray) fAlignObjArray->Delete(); // fAlignObjArray->RemoveAll() ???
+// delete fAlignObjArray; fAlignObjArray=0;
+
if (fBkgrdFileNames) {
fBkgrdFileNames->Delete();
delete fBkgrdFileNames;
fNEvents = nEvents;
}
+//_____________________________________________________________________________
+void AliSimulation::InitCDBStorage(const char* uri)
+{
+// 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())
+ {
+ AliWarningClass("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ AliWarningClass("Default CDB storage not yet set");
+ AliWarningClass(Form("Using default storage declared in AliSimulation: %s",uri));
+ AliWarningClass("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ SetDefaultStorage(uri);
+ }
+
+}
+
+//_____________________________________________________________________________
+void AliSimulation::SetDefaultStorage(const char* uri) {
+// activate a default CDB storage
+
+ AliCDBManager::Instance()->SetDefaultStorage(uri);
+
+}
+
+//_____________________________________________________________________________
+void AliSimulation::SetSpecificStorage(const char* detName, const char* uri) {
+// activate a detector-specific CDB storage
+
+ AliCDBManager::Instance()->SetSpecificStorage(detName, uri);
+
+}
+
//_____________________________________________________________________________
void AliSimulation::SetConfigFile(const char* fileName)
{
fGAliceFileName = absFileName;
delete[] absFileName;
}
+
+ AliDebug(2, Form("galice file name set to %s", fileName));
+}
+
+//_____________________________________________________________________________
+void AliSimulation::SetEventsPerFile(const char* detector, const char* type,
+ Int_t nEvents)
+{
+// set the number of events per file for the given detector and data type
+// ("Hits", "Summable Digits", "Digits", "Reconstructed Points" or "Tracks")
+
+ TNamed* obj = new TNamed(detector, type);
+ obj->SetUniqueID(nEvents);
+ 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; j<nvols; j++)
+ {
+ AliAlignObj* alobj = (AliAlignObj*) alObjArray->UncheckedAt(j);
+ if (alobj->ApplyToGeometry() == kFALSE) flag = kFALSE;
+ }
+
+ if (AliDebugLevelClass() >= 1) {
+ gGeoManager->CheckOverlaps(20);
+ 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
+ //
+
+ InitCDBStorage("local://$ALICE_ROOT");
+ 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;
+ AliInfo(Form("Alignment data loaded for: %s",
+ dataLoaded.Data()));
+ 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;
+ }
+ }
+
+ 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;
}
//_____________________________________________________________________________
{
// run the generation, simulation and digitization
+ InitCDBStorage(fCDBUri);
+
if (nEvents > 0) fNEvents = nEvents;
// generation and simulation -> hits
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;
// hits -> digits
if (!fMakeDigitsFromHits.IsNull()) {
if (fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
- Warning("Run", "Merging and direct creation of digits from hits "
- "was selected for some detectors. "
- "No merging will be done for the following detectors: %s",
- fMakeDigitsFromHits.Data());
+ AliWarning(Form("Merging and direct creation of digits from hits "
+ "was selected for some detectors. "
+ "No merging will be done for the following detectors: %s",
+ fMakeDigitsFromHits.Data()));
}
if (!RunHitsDigitization(fMakeDigitsFromHits)) {
if (fStopOnError) return kFALSE;
}
}
+ // digits -> trigger
+ if (!RunTrigger(fMakeTrigger)) {
+ if (fStopOnError) return kFALSE;
+ }
+
// digits -> raw data
if (!fWriteRawData.IsNull()) {
- if (!WriteRawData(fWriteRawData)) {
+ if (!WriteRawData(fWriteRawData, fRawDataFileName,
+ fDeleteIntermediateFiles)) {
if (fStopOnError) return kFALSE;
}
}
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( "CT" );
+ 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)
{
stopwatch.Start();
if (!gAlice) {
- Error("RunSimulation", "no gAlice object. Restart aliroot and try again.");
+ AliError("no gAlice object. Restart aliroot and try again.");
return kFALSE;
}
if (gAlice->Modules()->GetEntries() > 0) {
- Error("RunSimulation",
- "gAlice was already run. Restart aliroot and try again.");
+ AliError("gAlice was already run. Restart aliroot and try again.");
return kFALSE;
}
- Info("RunSimulation", "initializing gAlice with config file %s",
- fConfigFileName.Data());
- gAlice->Init(fConfigFileName.Data());
+ AliInfo(Form("initializing gAlice with config file %s",
+ fConfigFileName.Data()));
+ 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) {
- Error("RunSimulation", "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);
+
+ // Temporary fix by A.Gheata
+ // Could be removed with the next Root version (>5.11)
+ if (gGeoManager) {
+ TIter next(gGeoManager->GetListOfVolumes());
+ TGeoVolume *vol;
+ while ((vol = (TGeoVolume *)next())) {
+ if (vol->GetVoxels()) {
+ if (vol->GetVoxels()->NeedRebuild()) {
+ vol->GetVoxels()->Voxelize();
+ vol->FindOverlaps();
+ }
+ }
+ }
+ }
+
+ // 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()) {
- Error("RunSimulation", "gAlice has no generator object. "
- "Check your config file: %s", fConfigFileName.Data());
+ AliError(Form("gAlice has no generator object. "
+ "Check your config file: %s", fConfigFileName.Data()));
return kFALSE;
}
if (nEvents <= 0) nEvents = fNEvents;
Int_t signalPerBkgrd = GetNSignalPerBkgrd(nEvents);
const char* fileName = ((TObjString*)
(fBkgrdFileNames->At(0)))->GetName();
- Info("RunSimulation", "The vertex will be taken from the background "
- "file %s with nSignalPerBackground = %d",
- fileName, signalPerBkgrd);
+ AliInfo(Form("The vertex will be taken from the background "
+ "file %s with nSignalPerBackground = %d",
+ fileName, signalPerBkgrd));
AliVertexGenFile* vtxGen = new AliVertexGenFile(fileName, signalPerBkgrd);
gAlice->Generator()->SetVertexGenerator(vtxGen);
}
gAlice->Generator()->SetTrackingFlag(0);
}
- Info("RunSimulation", "running gAlice");
- gAlice->Run(nEvents);
+ // set the number of events per file for given detectors and data types
+ for (Int_t i = 0; i < fEventsPerFile.GetEntriesFast(); i++) {
+ if (!fEventsPerFile[i]) continue;
+ const char* detName = fEventsPerFile[i]->GetName();
+ const char* typeName = fEventsPerFile[i]->GetTitle();
+ TString loaderName(detName);
+ loaderName += "Loader";
+ AliLoader* loader = runLoader->GetLoader(loaderName);
+ if (!loader) {
+ AliError(Form("RunSimulation", "no loader for %s found\n"
+ "Number of events per file not set for %s %s",
+ detName, typeName, detName));
+ continue;
+ }
+ AliDataLoader* dataLoader =
+ loader->GetDataLoader(typeName);
+ if (!dataLoader) {
+ AliError(Form("no data loader for %s found\n"
+ "Number of events per file not set for %s %s",
+ typeName, detName, typeName));
+ continue;
+ }
+ dataLoader->SetNumberOfEventsPerFile(fEventsPerFile[i]->GetUniqueID());
+ AliDebug(1, Form("number of events per file set to %d for %s %s",
+ fEventsPerFile[i]->GetUniqueID(), detName, typeName));
+ }
+
+ AliInfo("running gAlice");
+ StdoutToAliInfo(StderrToAliError(
+ gAlice->Run(nEvents);
+ ););
delete runLoader;
- Info("RunSimulation", "execution time:");
- stopwatch.Print();
+ AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
+ stopwatch.RealTime(),stopwatch.CpuTime()));
return kTRUE;
}
AliModule* det = (AliModule*) detArray->At(iDet);
if (!det || !det->IsActive()) continue;
if (IsSelected(det->GetName(), detStr)) {
- Info("RunSDigitization", "creating summable digits for %s",
- det->GetName());
+ AliInfo(Form("creating summable digits for %s", det->GetName()));
TStopwatch stopwatchDet;
stopwatchDet.Start();
det->Hits2SDigits();
- Info("RunSDigitization", "execution time for %s:", det->GetName());
- stopwatchDet.Print();
+ AliInfo(Form("Execution time for %s: R:%.2fs C:%.2fs",
+ det->GetName(),stopwatchDet.RealTime(),stopwatchDet.CpuTime()));
}
}
if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
- Error("RunSDigitization", "the following detectors were not found: %s",
- detStr.Data());
+ AliError(Form("the following detectors were not found: %s",
+ detStr.Data()));
if (fStopOnError) return kFALSE;
}
delete runLoader;
- Info("RunSDigitization", "execution time:");
- stopwatch.Print();
+ AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
+ stopwatch.RealTime(),stopwatch.CpuTime()));
return kTRUE;
}
!IsSelected(det->GetName(), detExcl)) {
AliDigitizer* digitizer = det->CreateDigitizer(manager);
if (!digitizer) {
- Error("RunDigitization", "no digitizer for %s", det->GetName());
+ AliError(Form("no digitizer for %s", det->GetName()));
if (fStopOnError) return kFALSE;
} else {
digitizer->SetRegionOfInterest(fRegionOfInterest);
}
if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
- Error("RunDigitization", "the following detectors were not found: %s",
- detStr.Data());
+ AliError(Form("the following detectors were not found: %s",
+ detStr.Data()));
if (fStopOnError) return kFALSE;
}
if (!manager->GetListOfTasks()->IsEmpty()) {
- Info("RunDigitization", "executing digitization");
+ AliInfo("executing digitization");
manager->Exec("");
}
delete manager;
- Info("RunDigitization", "execution time:");
- stopwatch.Print();
-
+ AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
+ stopwatch.RealTime(),stopwatch.CpuTime()));
+
return kTRUE;
}
TStopwatch stopwatch;
stopwatch.Start();
- AliRunLoader* runLoader = LoadRun();
+ AliRunLoader* runLoader = LoadRun("READ");
if (!runLoader) return kFALSE;
TString detStr = detectors;
AliModule* det = (AliModule*) detArray->At(iDet);
if (!det || !det->IsActive()) continue;
if (IsSelected(det->GetName(), detStr)) {
- Info("RunHitsDigitization", "creating digits from hits for %s",
- det->GetName());
+ AliInfo(Form("creating digits from hits for %s", det->GetName()));
det->Hits2Digits();
}
}
if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
- Error("RunHitsDigitization", "the following detectors were not found: %s",
- detStr.Data());
+ AliError(Form("the following detectors were not found: %s",
+ detStr.Data()));
if (fStopOnError) return kFALSE;
}
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
- Info("RunHitsDigitization", "execution time:");
- stopwatch.Print();
+ AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
+ stopwatch.RealTime(),stopwatch.CpuTime()));
return kTRUE;
}
//_____________________________________________________________________________
-Bool_t AliSimulation::WriteRawData(const char* detectors)
+Bool_t AliSimulation::WriteRawData(const char* detectors,
+ const char* fileName,
+ Bool_t deleteIntermediateFiles)
{
// convert the digits to raw data
+// First DDL raw data files for the given detectors are created.
+// If a file name is given, the DDL files are then converted to a DATE file.
+// If deleteIntermediateFiles is true, the DDL raw files are deleted
+// afterwards.
+// 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.
TStopwatch stopwatch;
stopwatch.Start();
- AliRunLoader* runLoader = LoadRun();
+ if (!WriteRawFiles(detectors)) {
+ if (fStopOnError) return kFALSE;
+ }
+
+ TString dateFileName(fileName);
+ if (!dateFileName.IsNull()) {
+ Bool_t rootOutput = dateFileName.EndsWith(".root");
+ if (rootOutput) dateFileName += ".date";
+ if (!ConvertRawFilesToDate(dateFileName)) {
+ if (fStopOnError) return kFALSE;
+ }
+ if (deleteIntermediateFiles) {
+ AliRunLoader* runLoader = LoadRun("READ");
+ if (runLoader) for (Int_t iEvent = 0;
+ iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
+ char command[256];
+ sprintf(command, "rm -r raw%d", iEvent);
+ gSystem->Exec(command);
+ }
+ }
+
+ if (rootOutput) {
+ if (!ConvertDateToRoot(dateFileName, fileName)) {
+ if (fStopOnError) return kFALSE;
+ }
+ if (deleteIntermediateFiles) {
+ gSystem->Unlink(dateFileName);
+ }
+ }
+ }
+
+ AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
+ stopwatch.RealTime(),stopwatch.CpuTime()));
+
+ return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliSimulation::WriteRawFiles(const char* detectors)
+{
+// convert the digits to raw data DDL files
+
+ AliRunLoader* runLoader = LoadRun("READ");
if (!runLoader) return kFALSE;
+ // write raw data to DDL files
for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
- Info("WriteRawData", "processing event %d", iEvent);
+ AliInfo(Form("processing event %d", iEvent));
runLoader->GetEvent(iEvent);
TString baseDir = gSystem->WorkingDirectory();
char dirName[256];
sprintf(dirName, "raw%d", iEvent);
gSystem->MakeDirectory(dirName);
if (!gSystem->ChangeDirectory(dirName)) {
- Error("WriteRawData", "couldn't change to directory %s", dirName);
+ AliError(Form("couldn't change to directory %s", dirName));
if (fStopOnError) return kFALSE; else continue;
}
AliModule* det = (AliModule*) detArray->At(iDet);
if (!det || !det->IsActive()) continue;
if (IsSelected(det->GetName(), detStr)) {
- Info("WriteRawData", "creating raw data from digits for %s",
- det->GetName());
+ AliInfo(Form("creating raw data from digits for %s", det->GetName()));
det->Digits2Raw();
}
}
+ if (!WriteTriggerRawData())
+ if (fStopOnError) return kFALSE;
+
gSystem->ChangeDirectory(baseDir);
if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
- Error("WriteRawData", "the following detectors were not found: %s",
- detStr.Data());
+ AliError(Form("the following detectors were not found: %s",
+ detStr.Data()));
if (fStopOnError) return kFALSE;
}
}
delete runLoader;
+ return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliSimulation::ConvertRawFilesToDate(const char* dateFileName)
+{
+// convert raw data DDL files to a DATE file with the program "dateStream"
+
+ char* path = gSystem->Which(gSystem->Getenv("PATH"), "dateStream");
+ if (!path) {
+ AliError("the program dateStream was not found");
+ if (fStopOnError) return kFALSE;
+ } else {
+ delete[] path;
+ }
+
+ AliRunLoader* runLoader = LoadRun("READ");
+ if (!runLoader) return kFALSE;
+
+ AliInfo(Form("converting raw data DDL files to DATE file %s", dateFileName));
+ char command[256];
+ sprintf(command, "dateStream -D -o %s -# %d -C",
+ dateFileName, runLoader->GetNumberOfEvents());
+ FILE* pipe = gSystem->OpenPipe(command, "w");
+
+ for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
+ fprintf(pipe, "GDC\n");
+ Float_t ldc = 0;
+ 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++) {
+
+ Int_t ddlID = 0x100*iDet + iDDL;
+ Int_t ldcID = Int_t(ldc + 0.0001);
+ ldc += kDetectorLDCs[iDet] / kDetectorDDLs[iDet];
+
+ char rawFileName[256];
+ sprintf(rawFileName, "raw%d/%s_%d.ddl",
+ iEvent, kDetectors[iDet], ddlID);
+
+ // 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(pipe, " LDC Id %d\n", ldcID);
+ prevLDC = ldcID;
+ }
+ fprintf(pipe, " Equipment Id %d Payload %s\n", ddlID, rawFileName);
+ }
+ }
+ }
+
+ Int_t result = gSystem->ClosePipe(pipe);
+
+ delete runLoader;
+ return (result == 0);
+}
- Info("WriteRawData", "execution time:");
- stopwatch.Print();
+//_____________________________________________________________________________
+Bool_t AliSimulation::ConvertDateToRoot(const char* dateFileName,
+ const char* rootFileName)
+{
+// convert a DATE file to a root file with the program "alimdc"
- return kTRUE;
+ // ALIMDC setup
+ const Int_t kDBSize = 1000000000;
+ const Int_t kTagDBSize = 1000000000;
+ const Bool_t kFilter = kFALSE;
+ const Int_t kCompression = 1;
+
+ char* path = gSystem->Which(gSystem->Getenv("PATH"), "alimdc");
+ if (!path) {
+ AliError("the program alimdc was not found");
+ if (fStopOnError) return kFALSE;
+ } else {
+ delete[] path;
+ }
+
+ AliInfo(Form("converting DATE file %s to root file %s",
+ dateFileName, rootFileName));
+
+ const char* rawDBFS[2] = { "/tmp/mdc1", "/tmp/mdc2" };
+ const char* tagDBFS = "/tmp/mdc1/tags";
+ const char* runDBFS = "/tmp/mdc1/meta";
+
+ // 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");
+ if (gSystem->Getenv("ALIMDC_RUNDB"))
+ runDBFS = gSystem->Getenv("ALIMDC_RUNDB");
+
+ 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("rm -rf %s",runDBFS));
+
+ gSystem->Exec(Form("mkdir %s",rawDBFS[0]));
+ gSystem->Exec(Form("mkdir %s",rawDBFS[1]));
+ gSystem->Exec(Form("mkdir %s",tagDBFS));
+ gSystem->Exec(Form("mkdir %s",runDBFS));
+
+ 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));
+ gSystem->Exec(Form("rm -rf %s",runDBFS));
+
+ return (result == 0);
}
//_____________________________________________________________________________
-AliRunLoader* AliSimulation::LoadRun() const
+AliRunLoader* AliSimulation::LoadRun(const char* mode) const
{
// delete existing run loaders, open a new one and load gAlice
while (AliRunLoader::GetRunLoader()) delete AliRunLoader::GetRunLoader();
AliRunLoader* runLoader =
AliRunLoader::Open(fGAliceFileName.Data(),
- AliConfig::GetDefaultEventFolderName(), "UPDATE");
+ AliConfig::GetDefaultEventFolderName(), mode);
if (!runLoader) {
- Error("LoadRun", "no run loader found in file %s",
- fGAliceFileName.Data());
+ AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
return NULL;
}
runLoader->LoadgAlice();
gAlice = runLoader->GetAliRun();
if (!gAlice) {
- Error("LoadRun", "no gAlice object found in file %s",
- fGAliceFileName.Data());
+ AliError(Form("no gAlice object found in file %s",
+ fGAliceFileName.Data()));
return NULL;
}
return runLoader;
if (nSignalPerBkgrd <= 0) {
nSignalPerBkgrd = (nEvents-1) / nBkgrdEvents + 1;
} else if (result && (result != nSignalPerBkgrd)) {
- Info("GetNSignalPerBkgrd", "the number of signal events per "
- "background event will be changed from %d to %d for stream %d",
- nSignalPerBkgrd, result, iBkgrdFile+1);
+ AliInfo(Form("the number of signal events per background event "
+ "will be changed from %d to %d for stream %d",
+ nSignalPerBkgrd, result, iBkgrdFile+1));
nSignalPerBkgrd = result;
}
if (!result) result = nSignalPerBkgrd;
if (nSignalPerBkgrd * nBkgrdEvents < nEvents) {
- Warning("GetNSignalPerBkgrd", "not enough background events (%d) for "
- "%d signal events using %d signal per background events for "
- "stream %d",
- nBkgrdEvents, nEvents, nSignalPerBkgrd, iBkgrdFile+1);
+ AliWarning(Form("not enough background events (%d) for %d signal events "
+ "using %d signal per background events for stream %d",
+ nBkgrdEvents, nEvents, nSignalPerBkgrd, iBkgrdFile+1));
}
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff