// //
///////////////////////////////////////////////////////////////////////////////
-#include <TVirtualMCApplication.h>
+#include <TCint.h>
+#include <TFile.h>
#include <TGeoManager.h>
#include <TObjString.h>
-#include <TSystem.h>
-#include <TFile.h>
#include <TROOT.h>
+#include <TSystem.h>
+#include <TVirtualMC.h>
+#include <TVirtualMCApplication.h>
-#include "AliCodeTimer.h"
-#include "AliCDBStorage.h"
+#include "AliAlignObj.h"
#include "AliCDBEntry.h"
#include "AliCDBManager.h"
-#include "AliGeomManager.h"
-#include "AliAlignObj.h"
+#include "AliCDBStorage.h"
+#include "AliCTPRawData.h"
#include "AliCentralTrigger.h"
+#include "AliCentralTrigger.h"
+#include "AliCodeTimer.h"
#include "AliDAQ.h"
#include "AliDigitizer.h"
+#include "AliESD.h"
+#include "AliGRPObject.h"
+#include "AliGenEventHeader.h"
#include "AliGenerator.h"
+#include "AliGeomManager.h"
+#include "AliHLTSimulation.h"
+#include "AliHeader.h"
#include "AliLog.h"
+#include "AliMC.h"
+#include "AliMagF.h"
#include "AliModule.h"
+#include "AliPDG.h"
+#include "AliRawReaderDate.h"
+#include "AliRawReaderFile.h"
+#include "AliRawReaderRoot.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"
#include "AliSysInfo.h"
-#include "AliMagF.h"
+#include "AliVertexGenFile.h"
+#include "AliLegoGenerator.h"
+#include "AliLego.h"
ClassImp(AliSimulation)
fDeleteIntermediateFiles(kFALSE),
fWriteSelRawData(kFALSE),
fStopOnError(kFALSE),
-
fNEvents(1),
fConfigFileName(configFileName),
fGAliceFileName("galice.root"),
fInitRunNumberCalled(kFALSE),
fSetRunNumberFromDataCalled(kFALSE),
fEmbeddingFlag(kFALSE),
+ fLego(NULL),
fQADetectors("ALL"),
fQATasks("ALL"),
fQASteer(NULL),
fRunQA(kTRUE),
+ fEventSpecie(AliRecoParam::kDefault),
fRunHLT("default"),
fWriteGRPEntry(kTRUE)
{
SetGAliceFile("galice.root");
// for QA
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++)
- fQACycles[iDet] = 999999;
fQASteer = new AliQADataMakerSteer("sim") ;
fQASteer->SetActiveDetectors(fQADetectors) ;
fQATasks = Form("%d %d %d", AliQA::kHITS, AliQA::kSDIGITS, AliQA::kDIGITS) ;
fQASteer->SetTasks(fQATasks) ;
}
-//_____________________________________________________________________________
-AliSimulation::AliSimulation(const AliSimulation& sim) :
- TNamed(sim),
-
- fRunGeneration(sim.fRunGeneration),
- fRunSimulation(sim.fRunSimulation),
- fLoadAlignFromCDB(sim.fLoadAlignFromCDB),
- fLoadAlObjsListOfDets(sim.fLoadAlObjsListOfDets),
- fMakeSDigits(sim.fMakeSDigits),
- fMakeDigits(sim.fMakeDigits),
- fMakeTrigger(sim.fMakeTrigger),
- fMakeDigitsFromHits(sim.fMakeDigitsFromHits),
- fWriteRawData(sim.fWriteRawData),
- fRawDataFileName(""),
- fDeleteIntermediateFiles(kFALSE),
- fWriteSelRawData(kFALSE),
- fStopOnError(sim.fStopOnError),
-
- fNEvents(sim.fNEvents),
- fConfigFileName(sim.fConfigFileName),
- fGAliceFileName(sim.fGAliceFileName),
- fEventsPerFile(),
- fBkgrdFileNames(NULL),
- fAlignObjArray(NULL),
- fUseBkgrdVertex(sim.fUseBkgrdVertex),
- fRegionOfInterest(sim.fRegionOfInterest),
- fCDBUri(sim.fCDBUri),
- fSpecCDBUri(),
- fRun(-1),
- fSeed(0),
- fInitCDBCalled(sim.fInitCDBCalled),
- fInitRunNumberCalled(sim.fInitRunNumberCalled),
- fSetRunNumberFromDataCalled(sim.fSetRunNumberFromDataCalled),
- fEmbeddingFlag(sim.fEmbeddingFlag),
- fQADetectors(sim.fQADetectors),
- fQATasks(sim.fQATasks),
- fQASteer(sim.fQASteer),
- fRunQA(sim.fRunQA),
- fRunHLT(sim.fRunHLT),
- fWriteGRPEntry(sim.fWriteGRPEntry)
-{
-// 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;
- 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];
-}
-
-//_____________________________________________________________________________
-AliSimulation& AliSimulation::operator = (const AliSimulation& sim)
-{
-// assignment operator
-
- this->~AliSimulation();
- new(this) AliSimulation(sim);
- return *this;
-}
-
//_____________________________________________________________________________
AliSimulation::~AliSimulation()
{
AliRunLoader* runLoader = LoadRun("READ");
if (!runLoader) return kFALSE;
else {
- runData = runLoader->GetAliRun()->GetHeader()->GetRun();
+ runData = runLoader->GetHeader()->GetRun();
delete runLoader;
}
}
-
- // run HLT simulation
- if (!fRunHLT.IsNull()) {
+ // run HLT simulation on simulated digit data if raw data is not
+ // simulated, otherwise its called as part of WriteRawData
+ if (!fRunHLT.IsNull() && fWriteRawData.IsNull()) {
if (!RunHLT()) {
if (fStopOnError) return kFALSE;
}
return kTRUE;
}
+//_______________________________________________________________________
+Bool_t AliSimulation::RunLego(const char *setup, Int_t nc1, Float_t c1min,
+ Float_t c1max,Int_t nc2,Float_t c2min,Float_t c2max,
+ Float_t rmin,Float_t rmax,Float_t zmax, AliLegoGenerator* gener, Int_t nev)
+{
+ //
+ // Generates lego plots of:
+ // - radiation length map phi vs theta
+ // - radiation length map phi vs eta
+ // - interaction length map
+ // - g/cm2 length map
+ //
+ // ntheta bins in theta, eta
+ // themin minimum angle in theta (degrees)
+ // themax maximum angle in theta (degrees)
+ // nphi bins in phi
+ // phimin minimum angle in phi (degrees)
+ // phimax maximum angle in phi (degrees)
+ // rmin minimum radius
+ // rmax maximum radius
+ //
+ //
+ // The number of events generated = ntheta*nphi
+ // run input parameters in macro setup (default="Config.C")
+ //
+ // Use macro "lego.C" to visualize the 3 lego plots in spherical coordinates
+ //Begin_Html
+ /*
+ <img src="picts/AliRunLego1.gif">
+ */
+ //End_Html
+ //Begin_Html
+ /*
+ <img src="picts/AliRunLego2.gif">
+ */
+ //End_Html
+ //Begin_Html
+ /*
+ <img src="picts/AliRunLego3.gif">
+ */
+ //End_Html
+ //
+
+// run the generation and simulation
+
+ 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;
+ }
+ 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()));
+
+ // Number of events
+ if (nev == -1) nev = nc1 * nc2;
+
+ // check if initialisation has been done
+ // If runloader has been initialized, set the number of events per file to nc1 * nc2
+
+ // Set new generator
+ if (!gener) gener = new AliLegoGenerator();
+ //
+ // Configure Generator
+
+ gener->SetRadiusRange(rmin, rmax);
+ gener->SetZMax(zmax);
+ gener->SetCoor1Range(nc1, c1min, c1max);
+ gener->SetCoor2Range(nc2, c2min, c2max);
+
+
+ //Create Lego object
+ fLego = new AliLego("lego",gener);
+
+ //__________________________________________________________________________
+
+ gAlice->Announce();
+
+ gROOT->LoadMacro(setup);
+ gInterpreter->ProcessLine(gAlice->GetConfigFunction());
+
+ if(AliCDBManager::Instance()->GetRun() >= 0) {
+ SetRunNumber(AliCDBManager::Instance()->GetRun());
+ } else {
+ AliWarning("Run number not initialized!!");
+ }
+
+ AliRunLoader::GetRunLoader()->CdGAFile();
+
+ AliPDG::AddParticlesToPdgDataBase();
+
+ gAlice->GetMCApp()->Init();
+
+ //Must be here because some MCs (G4) adds detectors here and not in Config.C
+ gAlice->InitLoaders();
+ AliRunLoader::GetRunLoader()->MakeTree("E");
+
+ //
+ // Save stuff at the beginning of the file to avoid file corruption
+ AliRunLoader::GetRunLoader()->CdGAFile();
+ gAlice->Write();
+
+ //Save current generator
+ AliGenerator *gen=gAlice->GetMCApp()->Generator();
+ gAlice->GetMCApp()->ResetGenerator(gener);
+ //Prepare MC for Lego Run
+ gMC->InitLego();
+
+ //Run Lego Object
+
+
+ AliRunLoader::GetRunLoader()->SetNumberOfEventsPerFile(nev);
+ gMC->ProcessRun(nev);
+
+ // End of this run, close files
+ FinishRun();
+ // Restore current generator
+ gAlice->GetMCApp()->ResetGenerator(gen);
+ // Delete Lego Object
+ delete fLego;
+
+ return kTRUE;
+}
+
//_____________________________________________________________________________
Bool_t AliSimulation::RunTrigger(const char* config, const char* detectors)
{
TString trconfiguration = config;
if (trconfiguration.IsNull()) {
- if (gAlice->GetTriggerDescriptor() != "") {
+ if (strcmp(gAlice->GetTriggerDescriptor(),"")) {
trconfiguration = gAlice->GetTriggerDescriptor();
}
else
AliInfo(Form("initializing gAlice with config file %s",
fConfigFileName.Data()));
- StdoutToAliInfo(StderrToAliError(
- gAlice->Init(fConfigFileName.Data());
- ););
+
+ //
+ // Initialize ALICE Simulation run
+ //
+
+ gAlice->Announce();
+
+ gROOT->LoadMacro(fConfigFileName.Data());
+ gInterpreter->ProcessLine(gAlice->GetConfigFunction());
+
+ if(AliCDBManager::Instance()->GetRun() >= 0) {
+ gAlice->SetRunNumber(AliCDBManager::Instance()->GetRun());
+ } else {
+ AliWarning("Run number not initialized!!");
+ }
+
+ AliRunLoader::GetRunLoader()->CdGAFile();
+
+ AliPDG::AddParticlesToPdgDataBase();
+
+ gAlice->GetMCApp()->Init();
+
+ //Must be here because some MCs (G4) adds detectors here and not in Config.C
+ gAlice->InitLoaders();
+ AliRunLoader::GetRunLoader()->MakeTree("E");
+ AliRunLoader::GetRunLoader()->LoadKinematics("RECREATE");
+ AliRunLoader::GetRunLoader()->LoadTrackRefs("RECREATE");
+ AliRunLoader::GetRunLoader()->LoadHits("all","RECREATE");
+ //
+ // Save stuff at the beginning of the file to avoid file corruption
+ AliRunLoader::GetRunLoader()->CdGAFile();
+ gAlice->Write();
+ gAlice->SetEventNrInRun(-1); //important - we start Begin event from increasing current number in run
+ //___________________________________________________________________________________________
// Get the trigger descriptor string
// Either from AliSimulation or from
// gAlice
if (fMakeTrigger.IsNull()) {
- if (gAlice->GetTriggerDescriptor() != "")
+ if (strcmp(gAlice->GetTriggerDescriptor(),""))
fMakeTrigger = gAlice->GetTriggerDescriptor();
}
else
// Set run number in CDBManager
AliInfo(Form("Run number: %d",AliCDBManager::Instance()->GetRun()));
- AliRunLoader* runLoader = gAlice->GetRunLoader();
+ AliRunLoader* runLoader = AliRunLoader::GetRunLoader();
if (!runLoader) {
AliError(Form("gAlice has no run loader object. "
"Check your config file: %s", fConfigFileName.Data()));
MisalignGeometry(runLoader);
#endif
-// AliRunLoader* runLoader = gAlice->GetRunLoader();
+// AliRunLoader* runLoader = AliRunLoader::GetRunLoader();
// if (!runLoader) {
// AliError(Form("gAlice has no run loader object. "
// "Check your config file: %s", fConfigFileName.Data()));
// }
// SetGAliceFile(runLoader->GetFileName());
- if (!gAlice->Generator()) {
+ if (!gAlice->GetMCApp()->Generator()) {
AliError(Form("gAlice has no generator object. "
"Check your config file: %s", fConfigFileName.Data()));
return kFALSE;
"file %s with nSignalPerBackground = %d",
fileName, signalPerBkgrd));
AliVertexGenFile* vtxGen = new AliVertexGenFile(fileName, signalPerBkgrd);
- gAlice->Generator()->SetVertexGenerator(vtxGen);
+ gAlice->GetMCApp()->Generator()->SetVertexGenerator(vtxGen);
}
if (!fRunSimulation) {
- gAlice->Generator()->SetTrackingFlag(0);
+ gAlice->GetMCApp()->Generator()->SetTrackingFlag(0);
}
// set the number of events per file for given detectors and data types
AliInfo("running gAlice");
AliSysInfo::AddStamp("Start_simulation");
- StdoutToAliInfo(StderrToAliError(
- gAlice->Run(nEvents);
- ););
+
+ // Create the Root Tree with one branch per detector
+ //Hits moved to begin event -> now we are crating separate tree for each event
+
+ gMC->ProcessRun(nEvents);
+
+ // End of this run, close files
+ if(nEvents>0) FinishRun();
+
AliSysInfo::AddStamp("Stop_simulation");
delete runLoader;
if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
SetCDBLock();
- while (AliRunLoader::GetRunLoader()) delete AliRunLoader::GetRunLoader();
- if (gAlice) delete gAlice;
+ delete AliRunLoader::GetRunLoader();
+ delete gAlice;
gAlice = NULL;
Int_t nStreams = 1;
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
-
return kTRUE;
}
AliCodeTimerAuto("")
TString detStr = detectors;
- if (IsSelected("HLT", detStr))
- {
- // Do nothing. "HLT" will be removed from detStr because the HLT raw
- // data files are generated in RunHLT.
- }
-
if (!WriteRawFiles(detStr.Data())) {
if (fStopOnError) return kFALSE;
}
+ // run HLT simulation on simulated DDL raw files
+ // and produce HLT ddl raw files to be included in date/root file
+ if (IsSelected("HLT", detStr) && !fRunHLT.IsNull()) {
+ if (!RunHLT()) {
+ if (fStopOnError) return kFALSE;
+ }
+ }
+
TString dateFileName(fileName);
if (!dateFileName.IsNull()) {
Bool_t rootOutput = dateFileName.EndsWith(".root");
runNbFile.close();
TString detStr = detectors;
+ if (IsSelected("HLT", detStr)) {
+ // Do nothing. "HLT" will be removed from detStr and HLT raw
+ // data files are generated in RunHLT.
+ }
+
TObjArray* detArray = runLoader->GetAliRun()->Detectors();
for (Int_t iDet = 0; iDet < detArray->GetEntriesFast(); iDet++) {
AliModule* det = (AliModule*) detArray->At(iDet);
dateFileName, runLoader->GetNumberOfEvents(),runLoader->GetHeader()->GetRun());
FILE* pipe = gSystem->OpenPipe(command, "w");
+ if (!pipe) {
+ AliError(Form("Cannot execute command: %s",command));
+ return kFALSE;
+ }
+
Int_t selEvents = 0;
for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
{
// delete existing run loaders, open a new one and load gAlice
- while (AliRunLoader::GetRunLoader()) delete AliRunLoader::GetRunLoader();
+ delete AliRunLoader::GetRunLoader();
AliRunLoader* runLoader =
AliRunLoader::Open(fGAliceFileName.Data(),
AliConfig::GetDefaultEventFolderName(), mode);
//
// 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;
- }
+ 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()));
+
+ gAlice->Announce();
+
+ gROOT->LoadMacro(fConfigFileName.Data());
+ gInterpreter->ProcessLine(gAlice->GetConfigFunction());
+
+ if(AliCDBManager::Instance()->GetRun() >= 0) {
+ SetRunNumber(AliCDBManager::Instance()->GetRun());
+ } else {
+ AliWarning("Run number not initialized!!");
+ }
+
+ AliRunLoader::GetRunLoader()->CdGAFile();
- AliInfo(Form("initializing gAlice with config file %s",fConfigFileName.Data()));
- StdoutToAliInfo(StderrToAliError(gAlice->Init(fConfigFileName.Data());););
+ AliPDG::AddParticlesToPdgDataBase();
+
+ gAlice->GetMCApp()->Init();
+
+ //Must be here because some MCs (G4) adds detectors here and not in Config.C
+ gAlice->InitLoaders();
+ AliRunLoader::GetRunLoader()->MakeTree("E");
+ AliRunLoader::GetRunLoader()->LoadKinematics("RECREATE");
+ AliRunLoader::GetRunLoader()->LoadTrackRefs("RECREATE");
+ AliRunLoader::GetRunLoader()->LoadHits("all","RECREATE");
+ //
+ // Save stuff at the beginning of the file to avoid file corruption
+ AliRunLoader::GetRunLoader()->CdGAFile();
+ gAlice->Write();
//
// Initialize CDB
InitCDB();
Int_t iDet;
//
// Get the runloader
- AliRunLoader* runLoader = gAlice->GetRunLoader();
+ AliRunLoader* runLoader = AliRunLoader::GetRunLoader();
//
// Open esd file if available
TFile* esdFile = TFile::Open(esdFileName);
return kTRUE;
}
+//_____________________________________________________________________________
+void AliSimulation::FinishRun()
+{
+ //
+ // Called at the end of the run.
+ //
+
+ if(IsLegoRun())
+ {
+ AliDebug(1, "Finish Lego");
+ AliRunLoader::GetRunLoader()->CdGAFile();
+ fLego->FinishRun();
+ }
+
+ // Clean detector information
+ TIter next(gAlice->Modules());
+ AliModule *detector;
+ while((detector = dynamic_cast<AliModule*>(next()))) {
+ AliDebug(2, Form("%s->FinishRun()", detector->GetName()));
+ detector->FinishRun();
+ }
+
+ AliDebug(1, "AliRunLoader::GetRunLoader()->WriteHeader(OVERWRITE)");
+ AliRunLoader::GetRunLoader()->WriteHeader("OVERWRITE");
+
+ // Write AliRun info and all detectors parameters
+ AliRunLoader::GetRunLoader()->CdGAFile();
+ gAlice->Write(0,TObject::kOverwrite);//write AliRun
+ AliRunLoader::GetRunLoader()->Write(0,TObject::kOverwrite);//write RunLoader itself
+
+ if(gAlice->GetMCApp()) gAlice->GetMCApp()->FinishRun();
+ AliRunLoader::GetRunLoader()->Synchronize();
+}
+
//_____________________________________________________________________________
Int_t AliSimulation::GetDetIndex(const char* detector)
{
// 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
+ // http://web.ift.uib.no/~kjeks/doc/alice-hlt-current/
+ // http://web.ift.uib.no/~kjeks/doc/alice-hlt-current/classAliHLTModuleAgent.html
//
// The libraries to be loaded can be specified as an option.
// <pre>
// disable redirection of log messages to AliLog class
// \li config=<i>macro</i>
// configuration macro
- // \li localrec=<i>configuration</i>
+ // \li chains=<i>configuration</i>
// comma separated list of configurations to be run during simulation
+ // \li rawfile=<i>file</i>
+ // source for the RawReader to be created, the default is <i>./</i> if
+ // raw data is simulated
int iResult=0;
AliRunLoader* pRunLoader = LoadRun("READ");
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";
+ Char_t* date=0;
+ Char_t* time=0;
+ (*fctInfo)(date,time);
+ if (!date) {date=new Char_t[8]; strcpy(date,"unknown");}
+ if (!time) {time=new Char_t[8]; strcpy(time,"unknown");}
AliInfo(Form("%s build on %s (%s)", ALIHLTSIMULATION_LIBRARY, date, time));
+ delete date;
+ delete time;
} else {
AliInfo(Form("no build info available for %s", ALIHLTSIMULATION_LIBRARY));
}
// init the HLT simulation
TString options;
if (fRunHLT.CompareTo("default")!=0) options=fRunHLT;
- if (!IsSelected("HLT", fWriteRawData)) {
+ TString detStr = fWriteRawData;
+ if (!IsSelected("HLT", detStr)) {
options+=" writerawfiles=";
} else {
options+=" writerawfiles=HLT";
}
+
+ if (!detStr.IsNull() && !options.Contains("rawfile=")) {
+ // as a matter of fact, HLT will run reconstruction and needs the RawReader
+ // in order to get detector data. By default, RawReaderFile is used to read
+ // the already simulated ddl files. Date and Root files from the raw data
+ // are generated after the HLT simulation.
+ options+=" rawfile=./";
+ }
+
AliHLTSimulationInit_t fctInit=(AliHLTSimulationInit_t)(gSystem->DynFindSymbol(ALIHLTSIMULATION_LIBRARY, ALIHLTSIMULATION_INIT));
if (fctInit==NULL || (iResult=(fctInit(pHLT, pRunLoader, options.Data())))<0) {
AliError(Form("can not init HLT simulation: error %d (init %p)", iResult, fctInit));
{
// run the QA on summable hits, digits or digits
- fQASteer->SetRunLoader(gAlice->GetRunLoader()) ;
+ if(!gAlice) return kFALSE;
+ fQASteer->SetRunLoader(AliRunLoader::GetRunLoader()) ;
TString detectorsw("") ;
Bool_t rv = kTRUE ;
+ fQASteer->SetEventSpecie(fEventSpecie) ;
detectorsw = fQASteer->Run(fQADetectors.Data()) ;
if ( detectorsw.IsNull() )
rv = kFALSE ;
fRunQA = kTRUE ;
fQASteer->SetActiveDetectors(fQADetectors) ;
fQASteer->SetTasks(fQATasks) ;
+ for (Int_t det = 0 ; det < AliQA::kNDET ; det++)
+ fQASteer->SetWriteExpert(AliQA::DETECTORINDEX_t(det)) ;
+
return kTRUE;
}
AliInfo(Form("Run number = %d", fRun));
}
-//_____________________________________________________________________________
+//---------------------------------------------------------------------
void AliSimulation::WriteGRPEntry()
{
// Get the necessary information from galice (generator, trigger etc) and
// write a GRP entry corresponding to the settings in the Config.C used
+ // note that Hall probes and Cavern and Surface Atmos pressures are not simulated.
+
+
AliInfo("Writing global run parameters entry into the OCDB");
- TMap *grpMap = new TMap();
- grpMap->SetName("MONTECARLO");
+ AliGRPObject* grpObj = new AliGRPObject();
- grpMap->Add(new TObjString("fRunType"),new TObjString("PHYSICS"));
- grpMap->Add(new TObjString("fAliceStartTime"),new TObjString("0"));
- grpMap->Add(new TObjString("fAliceStopTime"),new TObjString("9999"));
+ grpObj->SetRunType("PHYSICS");
+ grpObj->SetTimeStart(0);
+ grpObj->SetTimeEnd(9999);
- const AliGenerator *gen = gAlice->Generator();
+ const AliGenerator *gen = gAlice->GetMCApp()->Generator();
if (gen) {
- grpMap->Add(new TObjString("fAliceBeamEnergy"),new TObjString(Form("%f",gen->GetEnergyCMS())));
+ grpObj->SetBeamEnergy(gen->GetEnergyCMS());
TString projectile;
Int_t a,z;
gen->GetProjectile(projectile,a,z);
TString target;
gen->GetTarget(target,a,z);
TString beamType = projectile + "-" + target;
+ beamType.ReplaceAll(" ","");
if (!beamType.CompareTo("-")) {
- grpMap->Add(new TObjString("fAliceBeamType"),new TObjString("UNKNOWN"));
+ grpObj->SetBeamType("UNKNOWN");
}
else {
- grpMap->Add(new TObjString("fAliceBeamType"),new TObjString(beamType.Data()));
+ grpObj->SetBeamType(beamType);
+ // Heavy ion run, the event specie is set to kHighMult
+ fEventSpecie = AliRecoParam::kHighMult;
+ if ((strcmp(beamType,"p-p") == 0) ||
+ (strcmp(beamType,"p-") == 0) ||
+ (strcmp(beamType,"-p") == 0) ||
+ (strcmp(beamType,"P-P") == 0) ||
+ (strcmp(beamType,"P-") == 0) ||
+ (strcmp(beamType,"-P") == 0)) {
+ // Proton run, the event specie is set to kLowMult
+ fEventSpecie = AliRecoParam::kLowMult;
+ }
}
- }
- else {
- AliWarning("Unknown beam type and energy!");
- grpMap->Add(new TObjString("fAliceBeamEnergy"),new TObjString("UNKNOWN"));
- grpMap->Add(new TObjString("fAliceBeamType"),new TObjString("0"));
+ } else {
+ AliWarning("Unknown beam type and energy! Setting energy to 0");
+ grpObj->SetBeamEnergy(0);
+ grpObj->SetBeamType("UNKNOWN");
}
UInt_t detectorPattern = 0;
nDets++;
}
}
+ // CTP
+ if (!fMakeTrigger.IsNull() || strcmp(gAlice->GetTriggerDescriptor(),""))
+ detectorPattern |= (1 << AliDAQ::DetectorID("TRG"));
+
// HLT
if (!fRunHLT.IsNull())
detectorPattern |= (1 << AliDAQ::kHLTId);
- grpMap->Add(new TObjString("fNumberOfDetectors"),new TObjString(Form("%d",nDets)));
- grpMap->Add(new TObjString("fDetectorMask"),new TObjString(Form("%u",detectorPattern)));
-
- grpMap->Add(new TObjString("fLHCPeriod"),new TObjString("LHC08c"));
-
- grpMap->Add(new TObjString("fLHCState"),new TObjString("STABLE BEAMS"));
- grpMap->Add(new TObjString("fLHCCondition"),new TObjString("0"));
- grpMap->Add(new TObjString("fLHCLuminosity"),new TObjString("0"));
- grpMap->Add(new TObjString("fBeamIntensity"),new TObjString("0"));
+ grpObj->SetNumberOfDetectors((Char_t)nDets);
+ grpObj->SetDetectorMask((Int_t)detectorPattern);
+ grpObj->SetLHCPeriod("LHC08c");
+ grpObj->SetLHCState("STABLE_BEAMS");
+ grpObj->SetLHCLuminosity(0,(AliGRPObject::Stats)0);
+ grpObj->SetBeamIntensity(0,(AliGRPObject::Stats)0);
AliMagF *field = gAlice->Field();
Float_t solenoidField = TMath::Abs(field->SolenoidField());
Float_t factor = field->Factor();
Float_t l3current = TMath::Abs(factor)*solenoidField*30000./5.;
- grpMap->Add(new TObjString("fL3Current"),new TObjString(Form("%f",l3current)));
+ grpObj->SetL3Current(l3current,(AliGRPObject::Stats)0);
if (factor > 0) {
- grpMap->Add(new TObjString("fL3Polarity"),new TObjString("0"));
- grpMap->Add(new TObjString("fDipolePolarity"),new TObjString("0"));
+ grpObj->SetL3Polarity(0);
+ grpObj->SetDipolePolarity(0);
}
else {
- grpMap->Add(new TObjString("fL3Polarity"),new TObjString("1"));
- grpMap->Add(new TObjString("fDipolePolarity"),new TObjString("1"));
+ grpObj->SetL3Polarity(1);
+ grpObj->SetDipolePolarity(1);
}
if (TMath::Abs(factor) != 0)
- grpMap->Add(new TObjString("fDipoleCurrent"),new TObjString("6000"));
+ grpObj->SetDipoleCurrent(6000,(AliGRPObject::Stats)0);
else
- grpMap->Add(new TObjString("fDipoleCurrent"),new TObjString("0"));
+ grpObj->SetDipoleCurrent(0,(AliGRPObject::Stats)0);
- grpMap->Add(new TObjString("fCavernTemperature"),new TObjString("0"));
- grpMap->Add(new TObjString("fCavernPressure"),new TObjString("0"));
+ grpObj->SetCavernTemperature(0,(AliGRPObject::Stats)0);
+
+ //grpMap->Add(new TObjString("fCavernPressure"),new TObjString("0")); ---> not inserted in simulation with the new object, since it is now an AliDCSSensor
// Now store the entry in OCDB
AliCDBManager* man = AliCDBManager::Instance();
- AliCDBId id("GRP/GRP/Data", man->GetRun(), man->GetRun());
+ AliCDBId id("GRP/GRP/Data", man->GetRun(), man->GetRun(), 1, 1);
AliCDBMetaData *metadata= new AliCDBMetaData();
metadata->SetResponsible("alice-off@cern.ch");
metadata->SetComment("Automatically produced GRP entry for Monte Carlo");
- man->Put(grpMap,id,metadata);
+ man->Put(grpObj,id,metadata);
}
+
+
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff