#include <TObjString.h>
#include <TSystem.h>
#include <TFile.h>
+#include <TROOT.h>
#include "AliCodeTimer.h"
#include "AliCDBStorage.h"
#include "AliGenEventHeader.h"
#include "AliMC.h"
#include "AliHLTSimulation.h"
-#include "AliQADataMakerSteer.h"
#include "AliSysInfo.h"
+#include "AliMagF.h"
+#include "AliGRPObject.h"
ClassImp(AliSimulation)
fInitRunNumberCalled(kFALSE),
fSetRunNumberFromDataCalled(kFALSE),
fEmbeddingFlag(kFALSE),
+ fQADetectors("ALL"),
+ fQATasks("ALL"),
+ fQASteer(NULL),
fRunQA(kTRUE),
- fRunHLT("default")
+ fRunHLT("default"),
+ fWriteGRPEntry(kTRUE)
{
// create simulation object with default parameters
fgInstance = this;
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) ;
}
//_____________________________________________________________________________
fInitRunNumberCalled(sim.fInitRunNumberCalled),
fSetRunNumberFromDataCalled(sim.fSetRunNumberFromDataCalled),
fEmbeddingFlag(sim.fEmbeddingFlag),
- fRunQA(kTRUE),
- fRunHLT(sim.fRunHLT)
+ fQADetectors(sim.fQADetectors),
+ fQATasks(sim.fQATasks),
+ fQASteer(sim.fQASteer),
+ fRunQA(sim.fRunQA),
+ fRunHLT(sim.fRunHLT),
+ fWriteGRPEntry(sim.fWriteGRPEntry)
{
// 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;
+ delete fQASteer ;
+
AliCodeTimer::Instance()->Print();
}
if (!AliGeomManager::GetGeometry()) {
// Initialize the geometry manager
AliGeomManager::LoadGeometry("geometry.root");
+
+// // Check that the consistency of symbolic names for the activated subdetectors
+// // in the geometry loaded by AliGeomManager
+// AliRunLoader* runLoader = LoadRun("READ");
+// if (!runLoader) return kFALSE;
+//
+// TString detsToBeChecked = "";
+// 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;
+// detsToBeChecked += det->GetName();
+// detsToBeChecked += " ";
+// } // end loop over detectors
+// if(!AliGeomManager::CheckSymNamesLUT(detsToBeChecked.Data()))
+ if(!AliGeomManager::CheckSymNamesLUT("ALL"))
+ AliFatalClass("Current loaded geometry differs in the definition of symbolic names!");
+
if (!AliGeomManager::GetGeometry()) if (fStopOnError) return kFALSE;
// Misalign geometry
if(!MisalignGeometry()) if (fStopOnError) return kFALSE;
}
-
- // 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;
}
TString trconfiguration = config;
if (trconfiguration.IsNull()) {
- if (gAlice->GetTriggerDescriptor() != "") {
+ if (strcmp(gAlice->GetTriggerDescriptor(),"")) {
trconfiguration = gAlice->GetTriggerDescriptor();
}
else
// Either from AliSimulation or from
// gAlice
if (fMakeTrigger.IsNull()) {
- if (gAlice->GetTriggerDescriptor() != "")
+ if (strcmp(gAlice->GetTriggerDescriptor(),""))
fMakeTrigger = gAlice->GetTriggerDescriptor();
}
else
// Misalign geometry
#if ROOT_VERSION_CODE < 331527
AliGeomManager::SetGeometry(gGeoManager);
+
+ // Check that the consistency of symbolic names for the activated subdetectors
+ // in the geometry loaded by AliGeomManager
+ TString detsToBeChecked = "";
+ 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;
+ detsToBeChecked += det->GetName();
+ detsToBeChecked += " ";
+ } // end loop over detectors
+ if(!AliGeomManager::CheckSymNamesLUT(detsToBeChecked.Data()))
+ AliFatalClass("Current loaded geometry differs in the definition of symbolic names!");
MisalignGeometry(runLoader);
#endif
"Check your config file: %s", fConfigFileName.Data()));
return kFALSE;
}
+
+ // Write GRP entry corresponding to the setting found in Cofig.C
+ if (fWriteGRPEntry)
+ WriteGRPEntry();
+
if (nEvents <= 0) nEvents = fNEvents;
// get vertex from background file in case of merging
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;
}
// accoring to the trigger cluster.
AliCodeTimerAuto("")
-
- if (!WriteRawFiles(detectors)) {
+
+ TString detStr = detectors;
+ 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");
if (fStopOnError) return kFALSE; else continue;
}
+ ofstream runNbFile(Form("run%u",runLoader->GetHeader()->GetRun()));
+ 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++) {
- fprintf(pipe, "GDC\n");
- Float_t ldc = 0;
- Int_t prevLDC = -1;
- if (selrawdata) {
+ UInt_t detectorPattern = 0;
+ runLoader->GetEvent(iEvent);
+ if (!runLoader->LoadTrigger()) {
+ AliCentralTrigger *aCTP = runLoader->GetTrigger();
+ detectorPattern = aCTP->GetClusterMask();
// Check if the event was triggered by CTP
- runLoader->GetEvent(iEvent);
- if (!runLoader->LoadTrigger()) {
- AliCentralTrigger *aCTP = runLoader->GetTrigger();
+ if (selrawdata) {
if (aCTP->GetClassMask()) selEvents++;
}
- else {
+ }
+ else {
+ AliWarning("No trigger can be loaded! Some fields in the event header will be empty !");
+ if (selrawdata) {
AliWarning("No trigger can be loaded! Writing of selected raw data is abandoned !");
selrawdata = kFALSE;
}
}
+ fprintf(pipe, "GDC DetectorPattern %u\n", detectorPattern);
+ Float_t ldc = 0;
+ Int_t prevLDC = -1;
+
// loop over detectors and DDLs
for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls(iDet); iDDL++) {
for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
// Get the trigger decision and cluster
+ UInt_t detectorPattern = 0;
TString detClust;
runLoader->GetEvent(iEvent);
if (!runLoader->LoadTrigger()) {
AliCentralTrigger *aCTP = runLoader->GetTrigger();
if (aCTP->GetClassMask() == 0) continue;
- detClust = aCTP->GetTriggeredDetectors();
+ detectorPattern = aCTP->GetClusterMask();
+ detClust = AliDAQ::ListOfTriggeredDetectors(detectorPattern);
AliInfo(Form("List of detectors to be read out: %s",detClust.Data()));
}
- fprintf(pipe2, "GDC\n");
+ fprintf(pipe2, "GDC DetectorPattern %u\n", detectorPattern);
Float_t ldc = 0;
Int_t prevLDC = -1;
rawReader = new AliRawReaderRoot(fileName);
} else if (!fileName.IsNull()) {
rawReader = new AliRawReaderDate(fileName);
- rawReader->SelectEvents(7);
}
// if (!fEquipIdMap.IsNull() && fRawReader)
// fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
// 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));
Bool_t AliSimulation::RunQA()
{
// run the QA on summable hits, digits or digits
-
- AliQADataMakerSteer qas ;
- qas.SetRunLoader(gAlice->GetRunLoader()) ;
+
+ if(!gAlice) return kFALSE;
+ fQASteer->SetRunLoader(gAlice->GetRunLoader()) ;
TString detectorsw("") ;
Bool_t rv = kTRUE ;
- detectorsw = qas.Run("ALL", AliQA::kHITS) ;
-// qas.Reset() ;
- detectorsw += qas.Run(fMakeSDigits.Data(), AliQA::kSDIGITS) ;
-// qas.Reset() ;
- detectorsw += qas.Run(fMakeDigits.Data(), AliQA::kDIGITS) ;
-// qas.Reset() ;
- detectorsw += qas.Run(fMakeDigitsFromHits.Data(), AliQA::kDIGITS) ;
-
+ detectorsw = fQASteer->Run(fQADetectors.Data()) ;
if ( detectorsw.IsNull() )
rv = kFALSE ;
+ else
+ fQASteer->EndOfCycle(detectorsw) ;
return rv ;
}
+//_____________________________________________________________________________
+Bool_t AliSimulation::SetRunQA(TString detAndAction)
+{
+ // Allows to run QA for a selected set of detectors
+ // and a selected set of tasks among HITS, SDIGITS and DIGITS
+ // all selected detectors run the same selected tasks
+
+ if (!detAndAction.Contains(":")) {
+ AliError( Form("%s is a wrong syntax, use \"DetectorList:ActionList\" \n", detAndAction.Data()) ) ;
+ fRunQA = kFALSE ;
+ return kFALSE ;
+ }
+ Int_t colon = detAndAction.Index(":") ;
+ fQADetectors = detAndAction(0, colon) ;
+ if (fQADetectors.Contains("ALL") )
+ fQADetectors = Form("%s %s", fMakeDigits.Data(), fMakeDigitsFromHits.Data()) ;
+ fQATasks = detAndAction(colon+1, detAndAction.Sizeof() ) ;
+ if (fQATasks.Contains("ALL") ) {
+ fQATasks = Form("%d %d %d", AliQA::kHITS, AliQA::kSDIGITS, AliQA::kDIGITS) ;
+ } else {
+ fQATasks.ToUpper() ;
+ TString tempo("") ;
+ if ( fQATasks.Contains("HIT") )
+ tempo = Form("%d ", AliQA::kHITS) ;
+ if ( fQATasks.Contains("SDIGIT") )
+ tempo += Form("%d ", AliQA::kSDIGITS) ;
+ if ( fQATasks.Contains("DIGIT") )
+ tempo += Form("%d ", AliQA::kDIGITS) ;
+ fQATasks = tempo ;
+ if (fQATasks.IsNull()) {
+ AliInfo("No QA requested\n") ;
+ fRunQA = kFALSE ;
+ return kTRUE ;
+ }
+ }
+ TString tempo(fQATasks) ;
+ tempo.ReplaceAll(Form("%d", AliQA::kHITS), AliQA::GetTaskName(AliQA::kHITS)) ;
+ tempo.ReplaceAll(Form("%d", AliQA::kSDIGITS), AliQA::GetTaskName(AliQA::kSDIGITS)) ;
+ tempo.ReplaceAll(Form("%d", AliQA::kDIGITS), AliQA::GetTaskName(AliQA::kDIGITS)) ;
+ AliInfo( Form("QA will be done on \"%s\" for \"%s\"\n", fQADetectors.Data(), tempo.Data()) ) ;
+ fRunQA = kTRUE ;
+ fQASteer->SetActiveDetectors(fQADetectors) ;
+ fQASteer->SetTasks(fQATasks) ;
+ return kTRUE;
+}
+
//_____________________________________________________________________________
void AliSimulation::ProcessEnvironmentVars()
{
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");
+
+ AliGRPObject* grpObj = new AliGRPObject();
+
+ grpObj->SetRunType("PHYSICS");
+ grpObj->SetTimeStart(0);
+ grpObj->SetTimeEnd(9999);
+
+ const AliGenerator *gen = gAlice->Generator();
+ if (gen) {
+ 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("-")) {
+
+ grpObj->SetBeamType("UNKNOWN");
+ }
+ else {
+ grpObj->SetBeamType(beamType);
+ }
+ }
+ else {
+ AliWarning("Unknown beam type and energy! Setting energy to 0");
+ grpObj->SetBeamEnergy(0);
+ grpObj->SetBeamType("UNKNOWN");
+ }
+
+ UInt_t detectorPattern = 0;
+ Int_t nDets = 0;
+ TObjArray *detArray = gAlice->Detectors();
+ for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors-1; iDet++) {
+ if (detArray->FindObject(AliDAQ::OfflineModuleName(iDet))) {
+ detectorPattern |= (1 << iDet);
+ nDets++;
+ }
+ }
+ // CTP
+ if (!fMakeTrigger.IsNull() || strcmp(gAlice->GetTriggerDescriptor(),""))
+ detectorPattern |= (1 << AliDAQ::DetectorID("TRG"));
+
+ // HLT
+ if (!fRunHLT.IsNull())
+ detectorPattern |= (1 << AliDAQ::kHLTId);
+
+ 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.;
+ grpObj->SetL3Current(l3current,(AliGRPObject::Stats)0);
+
+ if (factor > 0) {
+ grpObj->SetL3Polarity(0);
+ grpObj->SetDipolePolarity(0);
+ }
+ else {
+ grpObj->SetL3Polarity(1);
+ grpObj->SetDipolePolarity(1);
+ }
+
+ if (TMath::Abs(factor) != 0)
+ grpObj->SetDipoleCurrent(6000,(AliGRPObject::Stats)0);
+ else
+ grpObj->SetDipoleCurrent(0,(AliGRPObject::Stats)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(), 1, 1);
+ AliCDBMetaData *metadata= new AliCDBMetaData();
+
+ metadata->SetResponsible("alice-off@cern.ch");
+ metadata->SetComment("Automatically produced GRP entry for Monte Carlo");
+
+ man->Put(grpObj,id,metadata);
+}
+
+
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff