#include <TVirtualMCApplication.h>
#include <TGeoManager.h>
#include <TObjString.h>
-#include <TStopwatch.h>
#include <TSystem.h>
#include <TFile.h>
+#include "AliCodeTimer.h"
#include "AliCDBStorage.h"
#include "AliCDBEntry.h"
#include "AliCDBManager.h"
#include "AliCentralTrigger.h"
#include "AliCTPRawData.h"
#include "AliRawReaderFile.h"
+#include "AliRawReaderRoot.h"
+#include "AliRawReaderDate.h"
#include "AliESD.h"
#include "AliHeader.h"
#include "AliGenEventHeader.h"
#include "AliMC.h"
+#include "AliHLTSimulation.h"
+#include "AliQADataMakerSteer.h"
ClassImp(AliSimulation)
AliSimulation *AliSimulation::fgInstance = 0;
+const char* AliSimulation::fgkDetectorName[AliSimulation::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT"};
//_____________________________________________________________________________
-AliSimulation::AliSimulation(const char* configFileName, const char* cdbUri,
+AliSimulation::AliSimulation(const char* configFileName,
const char* name, const char* title) :
TNamed(name, title),
fAlignObjArray(NULL),
fUseBkgrdVertex(kTRUE),
fRegionOfInterest(kFALSE),
- fCDBUri(cdbUri),
+ fCDBUri(""),
fSpecCDBUri(),
- fEmbeddingFlag(kFALSE)
+ fRun(-1),
+ fSeed(0),
+ fInitCDBCalled(kFALSE),
+ fInitRunNumberCalled(kFALSE),
+ fSetRunNumberFromDataCalled(kFALSE),
+ fEmbeddingFlag(kFALSE),
+ fRunQA(kTRUE),
+ fRunHLT("default")
{
// create simulation object with default parameters
fgInstance = this;
SetGAliceFile("galice.root");
+
+// for QA
+ for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++)
+ fQACycles[iDet] = 999999;
}
//_____________________________________________________________________________
fRegionOfInterest(sim.fRegionOfInterest),
fCDBUri(sim.fCDBUri),
fSpecCDBUri(),
- fEmbeddingFlag(sim.fEmbeddingFlag)
+ fRun(-1),
+ fSeed(0),
+ fInitCDBCalled(sim.fInitCDBCalled),
+ fInitRunNumberCalled(sim.fInitRunNumberCalled),
+ fSetRunNumberFromDataCalled(sim.fSetRunNumberFromDataCalled),
+ fEmbeddingFlag(sim.fEmbeddingFlag),
+ fRunQA(kTRUE),
+ fRunHLT(sim.fRunHLT)
{
// copy constructor
if (sim.fSpecCDBUri[i]) fSpecCDBUri.Add(sim.fSpecCDBUri[i]->Clone());
}
fgInstance = this;
+
+// for QA
+ for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++)
+ fQACycles[iDet] = sim.fQACycles[iDet];
}
//_____________________________________________________________________________
fSpecCDBUri.Delete();
if (fgInstance==this) fgInstance = 0;
+
+ AliCodeTimer::Instance()->Print();
}
}
//_____________________________________________________________________________
-void AliSimulation::InitCDBStorage()
+void AliSimulation::InitCDB()
{
// activate a default CDB storage
// First check if we have any CDB storage set, because it is used
// to retrieve the calibration and alignment constants
+ if (fInitCDBCalled) return;
+ fInitCDBCalled = kTRUE;
+
AliCDBManager* man = AliCDBManager::Instance();
if (man->IsDefaultStorageSet())
{
AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
AliWarning("Default CDB storage has been already set !");
- AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fCDBUri.Data()));
+ AliWarning(Form("Ignoring the default storage declared in AliSimulation: %s",fCDBUri.Data()));
AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
- fCDBUri = "";
+ fCDBUri = man->GetDefaultStorage()->GetURI();
}
else {
- AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
- AliDebug(2, Form("Default CDB storage is set to: %s",fCDBUri.Data()));
- AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ if (fCDBUri.Length() > 0)
+ {
+ AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ AliDebug(2, Form("Default CDB storage is set to: %s", fCDBUri.Data()));
+ AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ } else {
+ fCDBUri="local://$ALICE_ROOT";
+ AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ AliWarning("Default CDB storage not yet set !!!!");
+ AliWarning(Form("Setting it now to: %s", fCDBUri.Data()));
+ AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+
+ }
man->SetDefaultStorage(fCDBUri);
}
AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
}
+
+}
+
+//_____________________________________________________________________________
+void AliSimulation::InitRunNumber(){
+// check run number. If not set, set it to 0 !!!!
+
+ if (fInitRunNumberCalled) return;
+ fInitRunNumberCalled = kTRUE;
+
+ AliCDBManager* man = AliCDBManager::Instance();
+ if (man->GetRun() >= 0)
+ {
+ if(fRun >= 0) {
+ AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ AliWarning(Form("Run number is already set in AliCDBManager: %d !", man->GetRun()));
+ AliWarning(Form("Ignoring the run number declared in AliSimulation: %d", fRun));
+ AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ }
+ fRun = man->GetRun();
+ }
+ else {
+ if(fRun >= 0) {
+ AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ AliDebug(2, Form("Setting CDB run number to: %d",fRun));
+ AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ } else {
+ fRun=0;
+ AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ AliWarning("Run number not yet set !!!!");
+ AliWarning(Form("Setting it now to: %d", fRun));
+ AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+
+ }
+ man->SetRun(fRun);
+ }
+
man->Print();
+
+}
+
+//_____________________________________________________________________________
+void AliSimulation::SetCDBLock() {
+ // Set CDB lock: from now on it is forbidden to reset the run number
+ // or the default storage or to activate any further storage!
+
+ AliCDBManager::Instance()->SetLock(1);
}
//_____________________________________________________________________________
}
+//_____________________________________________________________________________
+void AliSimulation::SetRunNumber(Int_t run)
+{
+// sets run number
+// Activate it later within the Run() method
+
+ fRun = run;
+}
+
+//_____________________________________________________________________________
+void AliSimulation::SetSeed(Int_t seed)
+{
+// sets seed number
+// Activate it later within the Run() method
+
+ fSeed = seed;
+}
+
+//_____________________________________________________________________________
+Bool_t AliSimulation::SetRunNumberFromData()
+{
+ // Set the CDB manager run number
+ // The run number is retrieved from gAlice
+
+ if (fSetRunNumberFromDataCalled) return kTRUE;
+ fSetRunNumberFromDataCalled = kTRUE;
+
+ AliCDBManager* man = AliCDBManager::Instance();
+ Int_t runData = -1, runCDB = -1;
+
+ AliRunLoader* runLoader = LoadRun("READ");
+ if (!runLoader) return kFALSE;
+ else {
+ runData = runLoader->GetAliRun()->GetHeader()->GetRun();
+ delete runLoader;
+ }
+
+ runCDB = man->GetRun();
+ if(runCDB >= 0) {
+ if (runCDB != runData) {
+ AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ AliWarning(Form("A run number was previously set in AliCDBManager: %d !", runCDB));
+ AliWarning(Form("It will be replaced with the run number got from run header: %d !", runData));
+ AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ }
+
+ }
+
+ man->SetRun(runData);
+ fRun = runData;
+
+ if(man->GetRun() < 0) {
+ AliError("Run number not properly initalized!");
+ return kFALSE;
+ }
+
+ man->Print();
+
+ return kTRUE;
+}
+
//_____________________________________________________________________________
void AliSimulation::SetConfigFile(const char* fileName)
{
// 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!");
+ if (!AliGeomManager::GetGeometry() || !AliGeomManager::GetGeometry()->IsClosed()) {
+ AliError("Can't apply the misalignment! Geometry is not loaded or it is still opened!");
return kFALSE;
}
+
+ // initialize CDB storage, run number, set CDB lock
+ InitCDB();
+// if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
+ SetCDBLock();
+
Bool_t delRunLoader = kFALSE;
if (!runLoader) {
runLoader = LoadRun("READ");
if (!runLoader) return kFALSE;
delRunLoader = kTRUE;
}
-
+
// Export ideal geometry
- gGeoManager->Export("geometry.root");
+ if(!gAlice->IsRootGeometry()) AliGeomManager::GetGeometry()->Export("geometry.root");
// Load alignment data from CDB and apply to geometry through AliGeomManager
if(fLoadAlignFromCDB){
loadAlObjsListOfDets += " ";
}
} // end loop over detectors
- (AliGeomManager::Instance())->ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
+ loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
+ 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::Instance())->ApplyAlignObjsToGeom(fAlignObjArray) == kFALSE) {
+ 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;
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;
}
{
// run the generation, simulation and digitization
- InitCDBStorage();
+
+ AliCodeTimerAuto("")
+
+ // Load run number and seed from environmental vars
+ ProcessEnvironmentVars();
+ gRandom->SetSeed(fSeed);
+
if (nEvents > 0) fNEvents = nEvents;
// generation and simulation -> hits
if (fRunGeneration) {
if (!RunSimulation()) if (fStopOnError) return kFALSE;
}
-
- // Set run number in CDBManager (if it is not already set in RunSimulation)
- if (!SetRunNumber()) if (fStopOnError) return kFALSE;
+
+ // initialize CDB storage from external environment
+ // (either CDB manager or AliSimulation setters),
+ // if not already done in RunSimulation()
+ InitCDB();
+
+ // Set run number in CDBManager from data
+ // From this point on the run number must be always loaded from data!
+ if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
+
+ // Set CDB lock: from now on it is forbidden to reset the run number
+ // or the default storage or to activate any further storage!
+ SetCDBLock();
// If RunSimulation was not called, load the geometry and misalign it
- if (!gGeoManager) {
- TGeoManager::Import("geometry.root");
- if (!gGeoManager) if (fStopOnError) return kFALSE;
- // Initialize the geometry manager (if not already done)
+ if (!AliGeomManager::GetGeometry()) {
+ // Initialize the geometry manager
+ AliGeomManager::LoadGeometry("geometry.root");
+ if (!AliGeomManager::GetGeometry()) if (fStopOnError) return kFALSE;
+ // Misalign geometry
if(!MisalignGeometry()) if (fStopOnError) return kFALSE;
}
// hits -> summable digits
if (!fMakeSDigits.IsNull()) {
if (!RunSDigitization(fMakeSDigits)) if (fStopOnError) return kFALSE;
+
}
+
- // summable digits -> digits
+
+ // summable digits -> digits
if (!fMakeDigits.IsNull()) {
if (!RunDigitization(fMakeDigits, fMakeDigitsFromHits)) {
if (fStopOnError) return kFALSE;
}
- }
+ }
+
+
// hits -> digits
if (!fMakeDigitsFromHits.IsNull()) {
if (fBkgrdFileNames && (fBkgrdFileNames->GetEntriesFast() > 0)) {
}
}
+
+
// digits -> trigger
if (!RunTrigger(fMakeTrigger)) {
if (fStopOnError) return kFALSE;
}
+
+
// digits -> raw data
if (!fWriteRawData.IsNull()) {
if (!WriteRawData(fWriteRawData, fRawDataFileName,
}
}
+
+
+ // run HLT simulation
+ if (!fRunHLT.IsNull()) {
+ if (!RunHLT()) {
+ if (fStopOnError) return kFALSE;
+ }
+ }
+
+ // //QA
+// if (fRunQA) {
+// Bool_t rv = RunQA() ;
+// if (!rv)
+// if (fStopOnError)
+// return kFALSE ;
+// }
+
+ // Cleanup of CDB manager: cache and active storages!
+ AliCDBManager::Instance()->ClearCache();
+
return kTRUE;
}
{
// run the trigger
- TStopwatch stopwatch;
- stopwatch.Start();
+ AliCodeTimerAuto("")
+ // initialize CDB storage from external environment
+ // (either CDB manager or AliSimulation setters),
+ // if not already done in RunSimulation()
+ InitCDB();
+
+ // Set run number in CDBManager from data
+ // From this point on the run number must be always loaded from data!
+ if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
+
+ // Set CDB lock: from now on it is forbidden to reset the run number
+ // or the default storage or to activate any further storage!
+ SetCDBLock();
+
AliRunLoader* runLoader = LoadRun("READ");
if (!runLoader) return kFALSE;
TString des = descriptors;
}
}
- AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
- stopwatch.RealTime(),stopwatch.CpuTime()));
-
delete runLoader;
return kTRUE;
{
// run the generation and simulation
- TStopwatch stopwatch;
- stopwatch.Start();
+ AliCodeTimerAuto("")
+ // initialize CDB storage and run number from external environment
+ // (either CDB manager or AliSimulation setters)
+ InitCDB();
+ InitRunNumber();
+ SetCDBLock();
+
if (!gAlice) {
AliError("no gAlice object. Restart aliroot and try again.");
return kFALSE;
StdoutToAliInfo(StderrToAliError(
gAlice->Init(fConfigFileName.Data());
););
-
+
// Get the trigger descriptor string
// Either from AliSimulation or from
// gAlice
return kFALSE;
}
SetGAliceFile(runLoader->GetFileName());
-
+
// Misalign geometry
#if ROOT_VERSION_CODE < 331527
+ AliGeomManager::SetGeometry(gGeoManager);
MisalignGeometry(runLoader);
#endif
delete runLoader;
- AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
- stopwatch.RealTime(),stopwatch.CpuTime()));
-
return kTRUE;
}
{
// run the digitization and produce summable digits
- TStopwatch stopwatch;
- stopwatch.Start();
+ AliCodeTimerAuto("")
+ // initialize CDB storage, run number, set CDB lock
+ InitCDB();
+ if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
+ SetCDBLock();
+
AliRunLoader* runLoader = LoadRun();
if (!runLoader) return kFALSE;
if (!det || !det->IsActive()) continue;
if (IsSelected(det->GetName(), detStr)) {
AliInfo(Form("creating summable digits for %s", det->GetName()));
- TStopwatch stopwatchDet;
- stopwatchDet.Start();
+ AliCodeTimerAuto(Form("creating summable digits for %s", det->GetName()));
+
det->Hits2SDigits();
- AliInfo(Form("Execution time for %s: R:%.2fs C:%.2fs",
- det->GetName(),stopwatchDet.RealTime(),stopwatchDet.CpuTime()));
}
}
delete runLoader;
- AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
- stopwatch.RealTime(),stopwatch.CpuTime()));
-
return kTRUE;
}
{
// run the digitization and produce digits from sdigits
- TStopwatch stopwatch;
- stopwatch.Start();
+ AliCodeTimerAuto("")
+ // initialize CDB storage, run number, set CDB lock
+ InitCDB();
+ if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
+ SetCDBLock();
+
while (AliRunLoader::GetRunLoader()) delete AliRunLoader::GetRunLoader();
if (gAlice) delete gAlice;
gAlice = NULL;
delete manager;
- AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
- stopwatch.RealTime(),stopwatch.CpuTime()));
-
return kTRUE;
}
{
// run the digitization and produce digits from hits
- TStopwatch stopwatch;
- stopwatch.Start();
+ AliCodeTimerAuto("")
+ // initialize CDB storage, run number, set CDB lock
+ InitCDB();
+ if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
+ SetCDBLock();
+
AliRunLoader* runLoader = LoadRun("READ");
if (!runLoader) return kFALSE;
//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(Form("Execution time: R:%.2fs C:%.2fs",
- stopwatch.RealTime(),stopwatch.CpuTime()));
-
return kTRUE;
}
// to a root file.
// If deleteIntermediateFiles is true, the DATE file is deleted afterwards.
- TStopwatch stopwatch;
- stopwatch.Start();
+ AliCodeTimerAuto("")
if (!WriteRawFiles(detectors)) {
if (fStopOnError) return kFALSE;
}
}
- AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
- stopwatch.RealTime(),stopwatch.CpuTime()));
-
return kTRUE;
}
{
// convert the digits to raw data DDL files
+ AliCodeTimerAuto("")
+
AliRunLoader* runLoader = LoadRun("READ");
if (!runLoader) return kFALSE;
}
delete runLoader;
+
return kTRUE;
}
{
// convert raw data DDL files to a DATE file with the program "dateStream"
+ AliCodeTimerAuto("")
+
char* path = gSystem->Which(gSystem->Getenv("PATH"), "dateStream");
if (!path) {
AliError("the program dateStream was not found");
const Int_t kDBSize = 2000000000;
const Int_t kTagDBSize = 1000000000;
const Bool_t kFilter = kFALSE;
- const Int_t kCompression = 0;
+ const Int_t kCompression = 1;
char* path = gSystem->Which(gSystem->Getenv("PATH"), "alimdc");
if (!path) {
return NULL;
}
runLoader->LoadgAlice();
+ runLoader->LoadHeader();
gAlice = runLoader->GetAliRun();
if (!gAlice) {
AliError(Form("no gAlice object found in file %s",
return result;
}
+//_____________________________________________________________________________
Bool_t AliSimulation::ConvertRaw2SDigits(const char* rawDirectory, const char* esdFileName)
{
//
StdoutToAliInfo(StderrToAliError(gAlice->Init(fConfigFileName.Data());););
//
// Initialize CDB
- InitCDBStorage();
- AliCDBManager* man = AliCDBManager::Instance();
- man->SetRun(0); // Should this come from rawdata header ?
+ InitCDB();
+ //AliCDBManager* man = AliCDBManager::Instance();
+ //man->SetRun(0); // Should this come from rawdata header ?
Int_t iDet;
//
}
//
// Create the RawReader
- AliRawReaderFile* rawReader = new AliRawReaderFile(rawDirectory);
+ TString fileName(rawDirectory);
+ AliRawReader* rawReader = 0x0;
+ if (fileName.EndsWith("/")) {
+ rawReader = new AliRawReaderFile(fileName);
+ } else if (fileName.EndsWith(".root")) {
+ rawReader = new AliRawReaderRoot(fileName);
+ } else if (!fileName.IsNull()) {
+ rawReader = new AliRawReaderDate(fileName);
+ rawReader->SelectEvents(7);
+ }
+// if (!fEquipIdMap.IsNull() && fRawReader)
+// fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
//
// Get list of detectors
TObjArray* detArray = runLoader->GetAliRun()->Detectors();
// Get Header
AliHeader* header = runLoader->GetHeader();
//
+ TString detStr = fMakeSDigits;
// Event loop
Int_t nev = 0;
while(kTRUE) {
// 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();
+ if (!det || !det->IsActive()) continue;
+ if (IsSelected(det->GetName(), detStr)) {
+ 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) {
return kTRUE;
}
+
+//_____________________________________________________________________________
+Int_t AliSimulation::GetDetIndex(const char* detector)
+{
+ // return the detector index corresponding to detector
+ Int_t index = -1 ;
+ for (index = 0; index < fgkNDetectors ; index++) {
+ if ( strcmp(detector, fgkDetectorName[index]) == 0 )
+ break ;
+ }
+ return index ;
+}
+
+//_____________________________________________________________________________
+Bool_t AliSimulation::RunHLT()
+{
+ // Run the HLT simulation
+ // HLT simulation is implemented in HLT/sim/AliHLTSimulation
+ // Disabled if fRunHLT is empty, default vaule is "default".
+ // AliSimulation::SetRunHLT can be used to set the options for HLT simulation
+ // The default simulation depends on the HLT component libraries and their
+ // corresponding agents which define components and chains to run. See
+ // http://web.ift.uib.no/~kjeks/doc/alice-hlt/
+ // http://web.ift.uib.no/~kjeks/doc/alice-hlt/classAliHLTModuleAgent.html
+ //
+ // The libraries to be loaded can be specified as an option.
+ // <pre>
+ // AliSimulation sim;
+ // sim.SetRunHLT("libAliHLTSample.so");
+ // </pre>
+ // will only load <tt>libAliHLTSample.so</tt>
+
+ // Other available options:
+ // \li loglevel=<i>level</i> <br>
+ // logging level for this processing
+ // \li alilog=off
+ // disable redirection of log messages to AliLog class
+ // \li config=<i>macro</i>
+ // configuration macro
+ // \li localrec=<i>configuration</i>
+ // comma separated list of configurations to be run during simulation
+
+ int iResult=0;
+ AliRunLoader* pRunLoader = LoadRun("READ");
+ if (!pRunLoader) return kFALSE;
+
+ // initialize CDB storage, run number, set CDB lock
+ InitCDB();
+ if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
+ SetCDBLock();
+
+ // load the library dynamically
+ gSystem->Load(ALIHLTSIMULATION_LIBRARY);
+
+ // check for the library version
+ AliHLTSimulationGetLibraryVersion_t fctVersion=(AliHLTSimulationGetLibraryVersion_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_GET_LIBRARY_VERSION));
+ if (!fctVersion) {
+ AliError(Form("can not load library %s", ALIHLTSIMULATION_LIBRARY));
+ return kFALSE;
+ }
+ if (fctVersion()!= ALIHLTSIMULATION_LIBRARY_VERSION) {
+ AliError(Form("%s version does not match: compiled for version %d, loaded %d", ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_LIBRARY_VERSION, fctVersion()));
+ return kFALSE;
+ }
+
+ // print compile info
+ typedef void (*CompileInfo)( char*& date, char*& time);
+ CompileInfo fctInfo=(CompileInfo)gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, "CompileInfo");
+ if (fctInfo) {
+ char* date="";
+ char* time="";
+ (*fctInfo)(date, time);
+ if (!date) date="unknown";
+ if (!time) time="unknown";
+ AliInfo(Form("%s build on %s (%s)", ALIHLTSIMULATION_LIBRARY, date, time));
+ } else {
+ AliInfo(Form("no build info available for %s", ALIHLTSIMULATION_LIBRARY));
+ }
+
+ // create instance of the HLT simulation
+ AliHLTSimulationCreateInstance_t fctCreate=(AliHLTSimulationCreateInstance_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_CREATE_INSTANCE));
+ AliHLTSimulation* pHLT=NULL;
+ if (fctCreate==NULL || (pHLT=(fctCreate()))==NULL) {
+ AliError(Form("can not create instance of HLT simulation (creator %p)", fctCreate));
+ return kFALSE;
+ }
+
+ // init the HLT simulation
+ if (fRunHLT.CompareTo("default")==0) fRunHLT="";
+ AliHLTSimulationInit_t fctInit=(AliHLTSimulationInit_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_INIT));
+ if (fctInit==NULL || (iResult=(fctInit(pHLT, pRunLoader, fRunHLT.Data())))<0) {
+ AliError(Form("can not init HLT simulation: error %d (init %p)", iResult, fctInit));
+ } else {
+ // run the HLT simulation
+ AliHLTSimulationRun_t fctRun=(AliHLTSimulationRun_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_RUN));
+ if (fctRun==NULL || (iResult=(fctRun(pHLT, pRunLoader)))<0) {
+ AliError(Form("can not run HLT simulation: error %d (run %p)", iResult, fctRun));
+ }
+ }
+
+ // delete the instance
+ AliHLTSimulationDeleteInstance_t fctDelete=(AliHLTSimulationDeleteInstance_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_DELETE_INSTANCE));
+ if (fctDelete==NULL || fctDelete(pHLT)<0) {
+ AliError(Form("can not delete instance of HLT simulation (creator %p)", fctDelete));
+ }
+ pHLT=NULL;
+
+ return iResult>=0?kTRUE:kFALSE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliSimulation::RunQA()
+{
+ // run the QA on summable hits, digits or digits
+
+ AliQADataMakerSteer qas ;
+ qas.SetRunLoader(gAlice->GetRunLoader()) ;
+
+ Bool_t rv = qas.Run("ALL", AliQA::kHITS) ;
+// qas.Reset() ;
+ rv *= qas.Run(fMakeSDigits.Data(), AliQA::kSDIGITS) ;
+// qas.Reset() ;
+ rv *= qas.Run(fMakeDigits.Data(), AliQA::kDIGITS) ;
+// qas.Reset() ;
+ rv *= qas.Run(fMakeDigitsFromHits.Data(), AliQA::kDIGITS) ;
+
+ return rv ;
+}
+
+//_____________________________________________________________________________
+void AliSimulation::ProcessEnvironmentVars()
+{
+// Extract run number and random generator seed from env variables
+
+ AliInfo("Processing environment variables");
+
+ // Random Number seed
+
+ // first check that seed is not already set
+ if (fSeed == 0) {
+ if (gSystem->Getenv("CONFIG_SEED")) {
+ fSeed = atoi(gSystem->Getenv("CONFIG_SEED"));
+ }
+ } else {
+ if (gSystem->Getenv("CONFIG_SEED")) {
+ AliInfo(Form("Seed for random number generation already set (%d)"
+ ": CONFIG_SEED variable ignored!", fSeed));
+ }
+ }
+
+ AliInfo(Form("Seed for random number generation = %d ", fSeed));
+
+ // Run Number
+
+ // first check that run number is not already set
+ if(fRun < 0) {
+ if (gSystem->Getenv("DC_RUN")) {
+ fRun = atoi(gSystem->Getenv("DC_RUN"));
+ }
+ } else {
+ if (gSystem->Getenv("DC_RUN")) {
+ AliInfo(Form("Run number already set (%d): DC_RUN variable ignored!", fRun));
+ }
+ }
+
+ AliInfo(Form("Run number = %d", fRun));
+}