// //
///////////////////////////////////////////////////////////////////////////////
+#include <TVirtualMCApplication.h>
+#include <TGeoManager.h>
#include <TObjString.h>
-#include <TStopwatch.h>
#include <TSystem.h>
-
-#include "AliLog.h"
+#include <TFile.h>
+
+#include "AliCodeTimer.h"
+#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 "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,
fRunGeneration(kTRUE),
fRunSimulation(kTRUE),
+ fLoadAlignFromCDB(kTRUE),
+ fLoadAlObjsListOfDets("ALL"),
fMakeSDigits("ALL"),
fMakeDigits("ALL"),
+ fMakeTrigger(""),
fMakeDigitsFromHits(""),
fWriteRawData(""),
fRawDataFileName(""),
fGAliceFileName("galice.root"),
fEventsPerFile(),
fBkgrdFileNames(NULL),
+ fAlignObjArray(NULL),
fUseBkgrdVertex(kTRUE),
- fRegionOfInterest(kFALSE)
+ fRegionOfInterest(kFALSE),
+ fCDBUri(""),
+ fSpecCDBUri(),
+ 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;
}
//_____________________________________________________________________________
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(""),
fGAliceFileName(sim.fGAliceFileName),
fEventsPerFile(),
fBkgrdFileNames(NULL),
+ fAlignObjArray(NULL),
fUseBkgrdVertex(sim.fUseBkgrdVertex),
- fRegionOfInterest(sim.fRegionOfInterest)
+ fRegionOfInterest(sim.fRegionOfInterest),
+ fCDBUri(sim.fCDBUri),
+ fSpecCDBUri(),
+ 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.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;
+
+// for QA
+ for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++)
+ fQACycles[iDet] = sim.fQACycles[iDet];
}
//_____________________________________________________________________________
// 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;
+
+ AliCodeTimer::Instance()->Print();
}
fNEvents = nEvents;
}
+//_____________________________________________________________________________
+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 AliSimulation: %s",fCDBUri.Data()));
+ AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ fCDBUri = man->GetDefaultStorage()->GetURI();
+ }
+ else {
+ 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);
+ }
+
+ // 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());
+ }
+
+}
+
+//_____________________________________________________________________________
+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::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::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)
{
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 (!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
+ if(!gAlice->IsRootGeometry()) AliGeomManager::GetGeometry()->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
+ 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::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;
+}
+
//_____________________________________________________________________________
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
+
+ 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;
}
+
+ // 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 (!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;
+}
+
+//_____________________________________________________________________________
+Bool_t AliSimulation::RunTrigger(const char* descriptors)
+{
+ // run the trigger
+
+ 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;
+
+ 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;
+ }
+ }
+
+ 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;
}
{
// 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
+ 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
+ AliGeomManager::SetGeometry(gGeoManager);
+ 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. "
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;
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*)
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;
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;
}
}
+ 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",
}
delete runLoader;
+
return kTRUE;
}
{
// 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};
-
+ AliCodeTimerAuto("")
+
char* path = gSystem->Which(gSystem->Getenv("PATH"), "dateStream");
if (!path) {
AliError("the program dateStream was not found");
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");
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");
// 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;
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);
}
return NULL;
}
runLoader->LoadgAlice();
+ runLoader->LoadHeader();
gAlice = runLoader->GetAliRun();
if (!gAlice) {
AliError(Form("no gAlice object found in file %s",
// 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;
}
// 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) {
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
+ InitCDB();
+ //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
+ 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) {
+ if (!(rawReader->NextEvent())) break;
+ //
+ // Detector loop
+ for (iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
+ AliModule* det = (AliModule*) detArray->At(iDet);
+ 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) {
+ 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;
+}
+
+//_____________________________________________________________________________
+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));
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff