// Commit
//------------------------------------------------------------------------------
/*virtual*/ bool FunctionSettings::Commit( NodeGraph & /*nodeGraph*/, const BFFIterator & funcStartIter ) const
{
// using a cache plugin?
AStackString<> cachePluginDLL;
if ( !GetString( funcStartIter, cachePluginDLL, ".CachePluginDLL" ) )
{
return false;
}
FBuild::Get().SetCachePluginDLL( cachePluginDLL );
if ( !cachePluginDLL.IsEmpty() )
{
FLOG_INFO( "CachePluginDLL: '%s'", cachePluginDLL.Get() );
}
// try to get the cache path from the config
const BFFVariable * cachePathVar;
if ( !GetString( funcStartIter, cachePathVar, ".CachePath" ) )
{
return false;
}
if ( cachePathVar )
{
s_CachePath = cachePathVar->GetString();
// override environment default only if not empty
if ( s_CachePath.IsEmpty() == false )
{
FBuild::Get().SetCachePath( s_CachePath );
}
}
// "Workers"
Array< AString > workerList;
if ( !GetStrings( funcStartIter, workerList, ".Workers" ) )
{
return false;
}
if ( !workerList.IsEmpty() )
{
FBuild::Get().SetWorkerList( workerList );
}
// "Environment"
Array< AString > environment;
if ( !GetStrings( funcStartIter, environment, ".Environment" ) )
{
return false;
}
if ( !environment.IsEmpty() )
{
ProcessEnvironment( environment );
}
return true;
}
void
Config()
{
/* initialise */
gROOT->LoadMacro("Sim/DetectorConfig.C");
gROOT->LoadMacro("Sim/GeneratorConfig.C");
ProcessEnvironment();
/* verbose */
printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
printf(">>>>> run number: %d \n", runNumber);
printf(">>>>> number of events: %d \n", neventsConfig);
printf(">>>>> magnetic field: %s \n", MagnetName[magnetConfig]);
printf(">>>>> detector: %s \n", DetectorName[detectorConfig]);
printf(">>>>> MC generator: %s \n", GeneratorName[generatorConfig]);
printf(">>>>> CMS energy: %f \n", energyConfig);
printf(">>>>> trigger: %s \n", TriggerName[triggerConfig]);
printf(">>>>> b-min: %f \n", bminConfig);
printf(">>>>> b-max: %f \n", bmaxConfig);
printf(">>>>> crossing angle: %f \n", crossingConfig);
printf(">>>>> random seed: %d \n", seedConfig);
printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
/* load libraries */
LoadLibraries();
/* setup geant */
new TGeant3TGeo("C++ Interface to Geant3");
/* create galice.root */
CreateGAlice();
/* configure detector */
DetectorConfig(detectorConfig, runNumber);
/* configure MC generator */
GeneratorConfig(generatorConfig, runNumber);
GeneratorOptions();
}
void
Config()
{
/* initialise */
#if ROOT_VERSION_CODE >= ROOT_VERSION(6,0,0)
// in root5 the ROOT_VERSION_CODE is defined only in ACLic mode
#else
gROOT->LoadMacro("$ALIDPG_ROOT/MC/DetectorConfig.C");
gROOT->LoadMacro("$ALIDPG_ROOT/MC/GeneratorConfig.C");
#endif
ProcessEnvironment();
/* verbose */
printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
printf(">>>>> run number: %d \n", runNumber);
printf(">>>>> number of events: %d \n", neventsConfig);
printf(">>>>> magnetic field: %s \n", MagnetName[magnetConfig]);
printf(">>>>> detector: %s \n", DetectorName[detectorConfig]);
printf(">>>>> MC generator: %s \n", GeneratorName[generatorConfig]);
printf(">>>>> process: %s \n", processConfig.Data());
printf(">>>>> system: %s \n", systemConfig.Data());
printf(">>>>> CMS energy: %f \n", energyConfig);
printf(">>>>> trigger: %s \n", TriggerName[triggerConfig]);
printf(">>>>> PDG: %d \n", pdgConfig);
printf(">>>>> b-min: %f \n", bminConfig);
printf(">>>>> b-max: %f \n", bmaxConfig);
printf(">>>>> ptHardMinHijing: %f \n", ptHardMinHijing);
printf(">>>>> y-min: %f \n", yminConfig);
printf(">>>>> y-max: %f \n", ymaxConfig);
printf(">>>>> phi-min (deg.): %f \n", phiminConfig);
printf(">>>>> phi-max (deg.): %f \n", phimaxConfig);
printf(">>>>> pt-min: %f \n", ptminConfig);
printf(">>>>> pt-max: %f \n", ptmaxConfig);
printf(">>>>> pt-hard min: %f \n", pthardminConfig);
printf(">>>>> pt-hard max: %f \n", pthardmaxConfig);
printf(">>>>> pt-trigger min: %f \n", pttrigminConfig);
printf(">>>>> pt-trigger max: %f \n", pttrigmaxConfig);
printf(">>>>> quenching: %d \n", quenchingConfig);
printf(">>>>> q-hat: %f \n", qhatConfig);
printf(">>>>> crossing angle: %f \n", crossingConfig);
printf(">>>>> random seed: %d \n", seedConfig);
printf(">>>>> geant4: %d \n", isGeant4);
printf(">>>>> purifyKine: %d \n", purifyKine);
printf(">>>>> fluka: %d \n", isFluka);
printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
#if ROOT_VERSION_CODE >= ROOT_VERSION(6,0,0)
// in root5 the ROOT_VERSION_CODE is defined only in ACLic mode
#else
LoadLibraries();
#endif
/* Check that it is not set both Geant4 and Fluka */
if (isGeant4 && isFluka) {
printf(">>>>> You cannot have in your parameters both Geant4 and Fluka set!: isGeant4 = %d, isFluka = %d \n", (Int_t)isGeant4, (Int_t)isFluka);
abort();
}
/* setup geant3 */
if (!isGeant4 && !isFluka) new TGeant3TGeo("C++ Interface to Geant3");
/* create galice.root */
CreateGAlice();
/* configure detector */
DetectorConfig(detectorConfig);
/* configure Geant4 if requested */
if (isGeant4) {
Int_t error;
TString geant4config_macro = "$ALIDPG_ROOT/MC/Geant4Config.C";
if (gROOT->LoadMacro(Form("%s/Geant4Config.C", gSystem->pwd()), &error, kTRUE) == 0) {
printf(">>>>> Geant4Config.C macro detected in CWD, using that one \n");
geant4config_macro = Form("%s/Geant4Config.C", gSystem->pwd());
}
gROOT->LoadMacro(geant4config_macro.Data());
gROOT->ProcessLine("Geant4Config();");
}
/* configure Fluka if requested */
if (isFluka) {
gSystem->Load("libfluka.so");
gROOT->ProcessLine("new TFluka(\"C++ Interface to Fluka\", 0/*verbositylevel*/);");
gROOT->ProcessLine("((TFluka*) gMC)->SetLowEnergyNeutronTransport(1);");
}
/* configure MC generator */
GeneratorConfig(generatorConfig);
GeneratorOptions();
if (!purifyKine) gAlice->GetMCApp()->PurifyLimits(80., 80.);
}
//______________________________________________________________________________
void AODtrain(Int_t merge=0)
{
// Main analysis train macro.
ProcessEnvironment();
UpdateFlags();
PrintSettings();
if (merge || doCDBconnect) {
TGrid::Connect("alien://");
if (!gGrid || !gGrid->IsConnected()) {
::Error("AODtrain", "No grid connection");
return;
}
}
// Set temporary merging directory to current one
gSystem->Setenv("TMPDIR", gSystem->pwd());
// Set temporary compilation directory to current one
gSystem->SetBuildDir(gSystem->pwd(), kTRUE);
printf("==================================================================\n");
printf("=========== RUNNING FILTERING TRAIN ==========\n");
printf("=========== Collision System is %s ==========\n",CollisionSystem[iCollision]);
printf("==================================================================\n");
printf("= Configuring analysis train for: =\n");
if (usePhysicsSelection) printf("= Physics selection =\n");
if (useTender) printf("= TENDER =\n");
if (iESDfilter) printf("= ESD filter =\n");
if (iMUONcopyAOD) printf("= MUON copy AOD =\n");
if (iJETAN) printf("= Jet analysis =\n");
if (iJETANdelta) printf("= Jet delta AODs =\n");
if (iPWGHFvertexing) printf("= PWGHF vertexing =\n");
if (iPWGDQJPSIfilter) printf("= PWGDQ j/psi filter =\n");
if (iPWGHFd2h) printf("= PWGHF D0->2 hadrons QA =\n");
// Make the analysis manager and connect event handlers
AliAnalysisManager *mgr = new AliAnalysisManager("Analysis Train", "Production train");
mgr->SetCacheSize(0);
if (useSysInfo) {
//mgr->SetNSysInfo(100);
AliSysInfo::SetVerbose(kTRUE);
}
// Create input handler (input container created automatically)
// ESD input handler
AliESDInputHandler *esdHandler = new AliESDInputHandler();
mgr->SetInputEventHandler(esdHandler);
// Monte Carlo handler
if (useMC) {
AliMCEventHandler* mcHandler = new AliMCEventHandler();
mgr->SetMCtruthEventHandler(mcHandler);
mcHandler->SetReadTR(useTR);
}
// AOD output container, created automatically when setting an AOD handler
if (iAODhandler) {
// AOD output handler
AliAODHandler* aodHandler = new AliAODHandler();
aodHandler->SetOutputFileName("AliAOD.root");
mgr->SetOutputEventHandler(aodHandler);
}
// Debugging if needed
if (useDBG) mgr->SetDebugLevel(3);
AddAnalysisTasks(cdbPath);
if (merge) {
AODmerge();
mgr->InitAnalysis();
mgr->SetGridHandler(new AliAnalysisAlien);
mgr->StartAnalysis("gridterminate",0);
return;
}
// Run the analysis
//
TChain *chain = CreateChain();
if (!chain) return;
TStopwatch timer;
timer.Start();
mgr->SetSkipTerminate(kTRUE);
if (mgr->InitAnalysis()) {
mgr->PrintStatus();
mgr->StartAnalysis("local", chain);
}
timer.Print();
}
//______________________________________________________________________________
void QAtrainsim(Int_t run = 0,
const char *xmlfile = "wn.xml",
Int_t stage = 0, /*0 = QA train, 1...n - merging stage*/
const char *cdb = "raw://")
{
run_number = run;
ProcessEnvironment();
//
// set OCDB source
TString ocdbConfig = "default,snapshot";
if (gSystem->Getenv("CONFIG_OCDB"))
ocdbConfig = gSystem->Getenv("CONFIG_OCDB");
if (stage != 0) {
//
gSystem->Setenv("CONFIG_RUN", gSystem->Getenv("ALIEN_JDL_LPMRUNNUMBER"));
// set OCDB
gROOT->LoadMacro("$ALIDPG_ROOT/MC/OCDBConfig.C");
OCDBDefault(1);
}
else if (ocdbConfig.Contains("alien") || ocdbConfig.Contains("cvmfs")) {
// set OCDB
gROOT->LoadMacro("$ALIDPG_ROOT/MC/OCDBConfig.C");
OCDBDefault(1);
}
else {
// set OCDB snapshot mode
AliCDBManager *cdbm = AliCDBManager::Instance();
cdbm->SetSnapshotMode("OCDBrec.root");
}
printf("------ Run QAtrainsim.C for collision type %s ------\n",CollisionSystem[iCollisionType]);
UpdateFlags();
TString cdbString(cdb);
if (cdbString.Contains("raw://") && !ocdbConfig.Contains("cvmfs")) {
TGrid::Connect("alien://");
if (!gGrid || !gGrid->IsConnected()) {
::Error("QAtrain", "No grid connection");
return;
}
}
// gSystem->SetIncludePath("-I. -I$ROOTSYS/include -I$ALICE_ROOT/include -I$ALICE_ROOT -I$ALICE_PHYSICS -I$ALICE_PHYSICS/include -I$ALICE_PHYSICS/PWGPP/TRD/macros");
// Set temporary merging directory to current one
gSystem->Setenv("TMPDIR", gSystem->pwd());
// Set temporary compilation directory to current one
gSystem->SetBuildDir(gSystem->pwd(), kTRUE);
// Load libraries
// LoadLibraries();
printf("Include path: %s\n", gSystem->GetIncludePath());
// Create manager
AliAnalysisManager *mgr = new AliAnalysisManager("PilotAnalysis_sim", "Production train");
mgr->SetRunFromPath(run_number);
// Input handler
AliESDInputHandlerRP *esdHandler = new AliESDInputHandlerRP();
esdHandler->SetReadFriends(kTRUE);
esdHandler->SetActiveBranches("ESDfriend");
mgr->SetInputEventHandler(esdHandler);
mgr->SetDebugLevel(debug_level);
// Monte Carlo handler
AliMCEventHandler* mcHandler = new AliMCEventHandler();
mgr->SetMCtruthEventHandler(mcHandler);
mcHandler->SetPreReadMode(1);
mcHandler->SetReadTR(kTRUE);
// subsidiary handler for mc-to-mc embedding
TString bgDir = gSystem->Getenv("CONFIG_BGEVDIR");
if (!bgDir.IsNull()) { // add extra handler for underlaying event
if (bgDir.BeginsWith("alien://") && !gGrid && !TGrid::Connect("alien://")) {
printf("Failed to create a grid connection\n");
abort();
}
if (!bgDir.EndsWith("/")) bgDir += "/";
AliMCEventHandler* mcHandlerBg = new AliMCEventHandler();
mcHandlerBg->SetInputPath(bgDir.Data());
mcHandlerBg->SetPreReadMode(1);
mcHandlerBg->SetReadTR(kTRUE);
mcHandler->AddSubsidiaryHandler(mcHandlerBg);
}
// AnalysisTasks
// mgr->Lock();
mgr->SetFileInfoLog("fileinfo.log");
AddAnalysisTasks(cdb);
// mgr->UnLock();
// mcHandler = (AliMCEventHandler*)mgr->GetMCtruthEventHandler();
// mcHandler->SetReadTR(kTRUE);
// mcHandler->SetPreReadMode(1);
if (stage>0) {
QAmerge(xmlfile, stage);
return;
}
// Input chain
TChain *chain = new TChain("esdTree");
chain->Add("AliESDs.root");
TStopwatch timer;
timer.Start();
if (mgr->InitAnalysis()) {
mgr->PrintStatus();
mgr->SetSkipTerminate(kTRUE);
// mgr->SetNSysInfo(1);
mgr->StartAnalysis("local", chain);
}
timer.Print();
}
