update config objects for MultiplicityCorrelations
[u/mrichter/AliRoot.git] / HMPID / AnalysisTrainHMPID.C
CommitLineData
66cdae53 1//===================== ANALYSIS TRAIN =========================================
2// To use: copy this macro to your work directory, modify the global part to match
3// your needs, then run root.
4// root[0] .L AnalysisTrainHMPID.C
5// Grid full mode as below (other modes: test, offline, submit, terminate)
6// root[1] AnalysisTrainHMPID("grid", "full")
7// CAF mode (requires root v5-23-02 + aliroot v4-16-Rev08)
8// root[2] AnalysisTrainHMPID("proof")
9// Local mode requires AliESds.root or AliAOD.root in ./data directory
10// root[3] AnalysisTrainHMPID("local")
11// In proof and grid modes, a token is needed and sourcing the produced environment file.
12//
13
14// =============================================================================
15// ### General Steering variables
16// =============================================================================
17//== general setup variables
18TString kTrainName = "hmpidAnalysis"; // (no blancs or special characters)
19TString kJobTag = "HMPID Tasks analysis train configured"; //
20Bool_t kUsePAR = kFALSE; // use par files for extra libs
21Bool_t kUseCPAR = kFALSE; // use par files for common libs
636bde73 22Bool_t kFillAOD = kFALSE; // switch of AOD filling for on the fly analysis
66cdae53 23
8e6dfee0 24Int_t iAODanalysis = 0; // Analysis on input AOD's
66cdae53 25Int_t iAODhandler = 1; // Analysis produces an AOD or dAOD's
26Int_t iESDfilter = 0; // ESD to AOD filter (barrel + muon tracks)
27Int_t iPhysicsSelection = 1; // Physics selection task
8e6dfee0 28Int_t iCentrality = 0; // Physics selection task
66cdae53 29Bool_t kUseKinefilter = kFALSE; // use Kinematics filter
30Bool_t kUseMuonfilter = kFALSE; // use muon filter
636bde73 31TString kCommonOutputFileName = "HmpidOutput.root";
66cdae53 32
33
34//== general process variables
35
36// ### Other flags to steer the analysis
37//==============================================================================
38Bool_t kSkipTerminate = kFALSE; // Do not call Teminate
39Bool_t kDebugLevel = kTRUE; // activate debugging
40Int_t kUseSysInfo = 0; // activate debugging
8e6dfee0 41Long64_t kNumberOfEvents = 1234567890; // number of events to process from the chain
42Bool_t kUseMC = kFALSE; // use MC info
43Bool_t kIsMC = kFALSE; // is MC info, if false it overwrites Use(AOD)MC
44Bool_t kUseESDTags = kFALSE; // use ESD tags for selection
66cdae53 45Bool_t kUseTR = kFALSE; // use track references
46
47// ### Analysis modules to be included. Some may not be yet fully implemented.
48//==============================================================================
a24020cd 49Int_t iHMPID = 1; // Basic HMPID analysis task
8e6dfee0 50Int_t iHMPIDperf = 0; // Basic HMPID performance task
66cdae53 51Int_t iJETAN = 0; // Jet analysis (PWG4) // 1 write standard 2 write non-standard jets
8e6dfee0 52Int_t iHMPIDJets = 0; // Jet chemistry with HMPID
66cdae53 53Int_t iJETANLib = 0;
54Int_t kHighPtFilterMask = 16; // change depending on the used AOD Filter
55
56
57//==============================================================================
58// ### PROOF Steering varibales
59//==============================================================================
60//== proof setup variables
61TString kProofCluster = "alice-caf.cern.ch";
62Bool_t kProofUseAFPAR = kTRUE; // use AF special par file
636bde73 63TString kProofAFversion = "VO_ALICE@AliRoot::v4-20-08-AN";
66cdae53 64//== proof input and output variables
636bde73 65TString kProofDataSet = "/alice/sim/LHC10d2_117220";
66cdae53 66//== proof process variables
67Bool_t kProofClearPackages = kFALSE;
68Int_t kProofEvents = 10000;
69Int_t kProofOffset = 0;
70
71//==============================================================================
72// ### Grid plugin Steering varibiables
73//==============================================================================
74//== grid plugin setup variables
75Bool_t kPluginUse = kTRUE; // do not change
76Bool_t kPluginUseProductionMode = kFALSE; // use the plugin in production mode
8e6dfee0 77TString kPluginRootVersion = "v5-28-00d"; // *CHANGE ME IF MORE RECENT IN GRID*
78TString kPluginAliRootVersion = "v4-21-26-AN"; // *CHANGE ME IF MORE RECENT IN GRID*
636bde73 79Bool_t kPluginMergeViaJDL = kTRUE; // merge via JDL
66cdae53 80Bool_t kPluginFastReadOption = kFALSE; // use xrootd flags to reduce timeouts
81Bool_t kPluginOverwriteMode = kTRUE; // overwrite existing collections
82Int_t kPluginOutputToRunNumber = 1; // write the output to subdirs named after run number
8e6dfee0 83TString kPluginExecutableCommand = "aliroot -b -q";
66cdae53 84
85// == grid plugin input and output variables
8e6dfee0 86TString kGridDatadir = "/alice/data/2010/LHC10e";
66cdae53 87TString kGridLocalRunList = "";
8e6dfee0 88TString kGridWorkDir = ""; // Alien working directory
66cdae53 89TString kGridOutdir = ""; // AliEn output directory. If blank will become output_<kTrainName>
90TString kGridDataSet = ""; // sub working directory not to confuse different run xmls
8e6dfee0 91Int_t kGridRunRange[2] = {128260,128260}; // Set the run range
66cdae53 92TString kGridRunPattern = "%03d"; // important for leading zeroes!!
8e6dfee0 93TString kGridPassPattern = "/ESDs/pass2";
66cdae53 94TString kGridExtraFiles = ""; // files that will be added to the input list in the JDL...
95Int_t kGridMaxMergeFiles = 12; // Number of files merged in a chunk grid run range
8e6dfee0 96Int_t kGridMaxMergeStages = 3; // Number of stages in the merging procedure
66cdae53 97TString kGridMergeExclude = "AliAOD.root"; // Files that should not be merged
98TString kGridOutputStorages = "disk=2"; // Make replicas on the storages
99// == grid process variables
100Int_t kGridRunsPerMaster = 1; // Number of runs per master job
101Int_t kGridFilesPerJob = 100; // Maximum number of files per job (gives size of AOD)
102
103//==============================================================================
104// ### Local Steering variables
105//==============================================================================
106//== local setup variables
107//== local input and output variables
108TString kLocalXMLDataset = ""; // Change local xml dataset for local interactive analysis
109TString kLocalDataList = "local_deltaaod.txt"; // Change local xml dataset for local interactive analysis
110// == local process variables
111
112
113
114// Temporaries.
115TString anaPars = "";
116TString anaLibs = "";
117TString anaLibsExtra = "";
118TString anaSources = "";
119// Function signatures
120class AliAnalysisAlien;
121
122//______________________________________________________________________________
123void AnalysisTrainHMPID(const char *analysis_mode="local", const char *plugin_mode="",
124 const char *config_file="",Int_t iOffset = 0)
125{
126// Main analysis train macro. If a configuration file is provided, all parameters
127// are taken from there but may be altered by CheckModuleFlags.
128
129 if (strlen(config_file) && !LoadConfig(config_file)) return;
130
131 if(iOffset)kProofOffset = iOffset;
132 TString smode(analysis_mode);
133 smode.ToUpper();
134 // Check compatibility of selected modules
135 CheckModuleFlags(smode);
136
137 printf("==================================================================\n");
138 printf("=========== RUNNING ANALYSIS TRAIN %s IN %s MODE ==========\n", kTrainName.Data(),smode.Data());
139 printf("==================================================================\n");
140 printf("= Configuring analysis train for: =\n");
8e6dfee0 141 if (iAODanalysis) printf("= AOD analysis =\n");
142 else printf("= ESD analysis =\n");
143 if (iPhysicsSelection) printf("= Physics selection =\n");
144 if (iCentrality) printf("= Centrality =\n");
66cdae53 145 if (iESDfilter) printf("= ESD filter =\n");
146 if (iJETAN) printf("= Jet analysis =\n");
8e6dfee0 147 if (iHMPID) printf("= HMPID generic =\n");
148 if (iHMPIDperf) printf("= HMPID performance =\n");
149 if (iHMPIDJets) printf("= HMPID Jet chemistry =\n");
66cdae53 150 printf("==================================================================\n");
151 printf(":: use MC truth %d\n", (UInt_t)kUseMC);
152 printf(":: use KINE filter %d\n", (UInt_t)kUseKinefilter);
153 printf(":: use track refs %d\n", (UInt_t)kUseTR);
154 printf(":: use tags %d\n", (UInt_t)kUseESDTags);
155 printf(":: use debugging %d\n", (UInt_t)kDebugLevel);
156 printf(":: use PAR files %d\n", (UInt_t)kUsePAR);
157 printf(":: use AliEn plugin %d\n", (UInt_t)kPluginUse);
158
159 //==========================================================================
160 // Connect to back-end system
161 if (!Connect(smode)) {
162 ::Error("AnalysisTrain", "Could not connect to %s back-end", analysis_mode);
163 return;
164 }
165
166 // Load common libraries and set include path
167 if (!LoadCommonLibraries(smode)) {
168 ::Error("AnalysisTrain", "Could not load common libraries");
169 return;
170 }
171
66cdae53 172
173 // Make the analysis manager and connect event handlers
174 AliAnalysisManager *mgr = new AliAnalysisManager("HMPIDTrain", "HMPID train");
175 if (kCommonOutputFileName.Length()>0)mgr->SetCommonFileName(kCommonOutputFileName.Data());
176 mgr->SetNSysInfo(0);
177 if (!strcmp(plugin_mode, "test")) mgr->SetNSysInfo(1);
178 if (kUseSysInfo)mgr->SetNSysInfo(kUseSysInfo);
179 mgr->SetSkipTerminate(kSkipTerminate);
180
181 // Load analysis specific libraries
182 if (!LoadAnalysisLibraries(smode)) {
183 ::Error("AnalysisTrain", "Could not load analysis libraries");
184 return;
185 }
186
187 // Create input handler (input container created automatically)
8e6dfee0 188 if (iAODanalysis) {
189 // AOD input handler
190 AliAODInputHandler *aodH = new AliAODInputHandler();
191 mgr->SetInputEventHandler(aodH);
192 } else {
66cdae53 193 // ESD input handler
8e6dfee0 194 AliESDInputHandler *esdHandler = new AliESDInputHandler();
195 if (kUseESDTags) esdHandler->SetReadTags();
196 esdHandler->SetReadFriends(kTRUE);
197 mgr->SetInputEventHandler(esdHandler);
198 }
66cdae53 199
200 // Monte Carlo handler
8e6dfee0 201 if (kUseMC && !iAODanalysis) {
66cdae53 202 AliMCEventHandler* mcHandler = new AliMCEventHandler();
203 mgr->SetMCtruthEventHandler(mcHandler);
204 mcHandler->SetReadTR(kUseTR);
205 }
206
207 // AOD output container, created automatically when setting an AOD handler
208 if (iAODhandler) {
209 // AOD output handler
210 AliAODHandler* aodHandler = new AliAODHandler();
211 aodHandler->SetOutputFileName("AliAOD.root");
212 aodHandler->SetFillAODforRun(kFillAOD);
213
214 mgr->SetOutputEventHandler(aodHandler);
215 AliAnalysisDataContainer *cout_aod = mgr->GetCommonOutputContainer();
216 cout_aod->SetSpecialOutput();
217 }
218
219 // Debugging if needed
220 if (kDebugLevel){
221 mgr->SetDebugLevel(3);
222 }
223 if(kUseSysInfo>0){
224 mgr->RegisterExtraFile("syswatch.root");
225 if(kGridMergeExclude.Length())kGridMergeExclude += " ";
226 kGridMergeExclude += "syswatch.root";
227 } else {
228 AliLog::SetGlobalLogLevel(AliLog::kError);
229 }
230
231 //==========================================================================
232 // Create the chain. In this example it is created only from ALIEN files but
233 // can be done to work in batch or grid mode as well.
234 TChain *chain = CreateChain(smode, plugin_mode);
235
236 //==========================================================================
237 // Load the tasks configuration macros for all wagons. These files are supposed now to be
238 // in the current workdir, but in AliEn they will be in the file catalog,
239 // mapped from AliRoot and pecified in the jdl input list.
8e6dfee0 240 if(iPhysicsSelection && !iAODanalysis){
66cdae53 241 gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
242 AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(kIsMC,kTRUE,kTRUE); // last flag also adds information on
243 }
8e6dfee0 244
245 if(iCentrality && !iAODanalysis){
246 gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskCentrality.C");
247 AliCentralitySelectionTask *taskCentrality = AddTaskCentrality();
248 taskCentrality->SetPass(2); // remember to set the pass you are processing!!!
249 }
66cdae53 250
8e6dfee0 251 if (iESDfilter && !iAODanalysis) {
66cdae53 252 // ESD filter task configuration.
253 gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskESDFilter.C");
254 AliAnalysisTaskESDfilter *taskesdfilter = AddTaskESDFilter(kUseKinefilter,kUseMuonfilter);
255 if(kIsMC){
256 mgr->RegisterExtraFile("pyxsec_hists.root");
257 if(kGridMergeExclude.Length())kGridMergeExclude += " ";
258 kGridMergeExclude += "pyxsec_hists.root";
259 }
260 }
261
262 // Jet analysis
263 if (iJETAN) {
264 gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJets.C");
265 AliAnalysisTaskJets *taskjets = 0;
266 if (iJETAN&1) taskjets = AddTaskJets(kHighPtFilterMask);
267 if (!taskjets) ::Warning("AnalysisTrainHMPID", "AliAnalysisTaskJets cannot run for this train conditions - EXCLUDED");
268 }
269
270 if(iHMPID){
271 gROOT->LoadMacro("$ALICE_ROOT/HMPID/AddTaskHMPID.C");
272 AliHMPIDAnalysisTask *taskHmpid = AddTaskHMPID(kUseMC);
8e6dfee0 273 if (!taskHmpid) ::Warning("AnalysisTrainHMPID", "AliHMPIDAnalysisTask cannot run for this train conditions - EXCLUDED");
ce6ae14b 274 }
8e6dfee0 275
276 if(iHMPIDperf){
277 gROOT->LoadMacro("$ALICE_ROOT/HMPID/AddTaskHMPIDPerformance.C");
278 AliHMPIDPerformanceTask *taskHmpidPerformance = AddTaskHMPIDPerformance(kUseMC);
279 if (!taskHmpidPerformance) ::Warning("AnalysisTrainHMPID", "AliHMPIDPerformanceTask cannot run for this train conditions - EXCLUDED");
280 }
281
282 if(iHMPIDJets){
283 gROOT->LoadMacro("$ALICE_ROOT/HMPID/AddTaskJetsHMPID.C");
284 AliAnalysisTaskJetsHMPID *taskHmpidJets = AddTaskJetsHMPID("clustersAOD_ANTIKT04_B0_Filter00256_Cut00150_Skip00","jeteventbackground_clustersAOD_KT04_B0_Filter00256_Cut00150_Skip00");
285 if (!taskHmpidJets) ::Warning("AnalysisTrainHMPID", "AliAnalysisTaskJetsHMPID cannot run for this train conditions - EXCLUDED");
286 }
287
66cdae53 288 if (kPluginUse) {
289 AliAnalysisGrid *alienHandler = CreateAlienHandler(plugin_mode);
290 AliAnalysisManager::GetAnalysisManager()->SetGridHandler(alienHandler);
291 }
292
293 if (mgr->InitAnalysis()) {
294 mgr->PrintStatus();
295 if (!strcmp(plugin_mode,"submit") && smode=="GRID"){
296 TString alien_workdir = gGrid->GetHomeDirectory();
297 alien_workdir += kGridWorkDir.Data();
298 if(kGridDataSet.Length()>0)alien_workdir += Form("/%s",kGridDataSet.Data());
299 AliAnalysisAlien *gridhandler = (AliAnalysisAlien*)mgr->GetGridHandler();
300 printf("=== AnalysisTrainHMPID:: Registering jdl in the work directory alien://%s/%s, should be done by the manager! ===\n",
301 alien_workdir.Data(),gridhandler->GetGridOutputDir());
302
303 TString dest;
304 dest = Form("%s/%s/%s.jdl",alien_workdir.Data(),gridhandler->GetGridOutputDir(),kTrainName.Data());
305 if(AliAnalysisAlien::FileExists(dest.Data())){
306 // Printf("%s exist on grid removing...",dest.Data());
307 // gGrid->Rm(dest.Data());
308 }
309 TFile::Cp(Form("file:%s.jdl",kTrainName.Data()),Form("alien://%s",dest.Data()));
310
311
312 TString dest;
313 dest = Form("%s/%s/%s_merge.jdl",alien_workdir.Data(),gridhandler->GetGridOutputDir(),kTrainName.Data());
314 if(AliAnalysisAlien::FileExists(dest.Data())){
315 // Printf("%s exist on grid removing...",dest.Data());
316 // gGrid->Rm(dest.Data());
317 }
318 TFile::Cp(Form("file:%s_merge.jdl",kTrainName.Data()),Form("alien://%s",dest.Data()));
319 }
320
321 AliLog::SetGlobalLogLevel(AliLog::kError);
322 if((kUseSysInfo>0 && smode=="LOCAL") || !strcmp(plugin_mode, "test")){
323 TFile *fM = TFile::Open("manager_local.root","RECREATE");
324 mgr->Write();
325 fM->Close();
326 }
327
328 StartAnalysis(smode, chain);
329
330 if((kUseSysInfo>0 && smode=="LOCAL") || !strcmp(plugin_mode, "test")){
331 for(int i = 0;i < mgr->GetTopTasks()->GetEntries();i++){
332 mgr->ProfileTask(i);
333 }
334 }
335 if (!strcmp(plugin_mode, "offline") && smode=="GRID"){
336 // Offline mode path files
337 // PatchJDL();
338 PatchAnalysisMacro();
339 }
340 }
341}
342
343
344//______________________________________________________________________________
345void StartAnalysis(const char *mode, TChain *chain) {
346
347 Int_t imode = -1;
348 AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
349 if (!strcmp(mode, "LOCAL")) imode = 0;
350 if (!strcmp(mode, "PROOF")) imode = 1;
351 if (!strcmp(mode, "GRID")) imode = 2;
352 switch (imode) {
353 case 0:
354 if (!chain) {
355 ::Error("AnalysisTrainHMPID.C::StartAnalysis", "Cannot create the chain");
356 return;
357 }
8e6dfee0 358 mgr->StartAnalysis(mode, chain, kNumberOfEvents);
66cdae53 359 return;
360 case 1:
361 if (!kProofDataSet.Length()) {
362 ::Error("AnalysisTrainHMPID.C::StartAnalysis", "kProofDataSet is empty");
363 return;
364 }
365 mgr->StartAnalysis(mode, kProofDataSet, kProofEvents,kProofOffset);
366 return;
367 case 2:
368 if (kPluginUse) {
369 if (!mgr->GetGridHandler()) {
370 ::Error("AnalysisTrainHMPID.C::StartAnalysis", "Grid plugin not initialized");
371 return;
372 }
373 mgr->StartAnalysis("grid");
374 } else {
375 if (!chain) {
376 ::Error("AnalysisTrainHMPID.C::StartAnalysis", "Cannot create the chain");
377 return;
378 }
379 mgr->StartAnalysis(mode, chain);
380 }
381 return;
382 }
383}
384
385//______________________________________________________________________________
386void CheckModuleFlags(const char *mode) {
387// Checks selected modules and insure compatibility
388 Int_t imode = -1;
389 if (!strcmp(mode, "LOCAL")) imode = 0;
390 if (!strcmp(mode, "PROOF")) imode = 1;
391 if (!strcmp(mode, "GRID")) imode = 2;
392
393
394 if (kUseCPAR) {
395 kPluginAliRootVersion = ""; // NO aliroot if we use CPAR
396 }
397
398 if (imode==1) {
399 if (!kUsePAR) {
400 ::Info("AnalysisTrainHMPID.C::CheckModuleFlags", "PAR files enabled due to PROOF analysis");
401 kUsePAR = kTRUE;
402 }
403 }
404 if (imode != 2) {
405 ::Info("AnalysisTrainHMPID.C::CheckModuleFlags", "AliEn plugin disabled since not in GRID mode");
406 kPluginUse = kFALSE;
407 }
408
409 if(!kIsMC){
8e6dfee0 410 // switch off anything related to MC
411 kUseMC = kFALSE;
412 kUseTR = kFALSE;
66cdae53 413 }
414
8e6dfee0 415 if (iAODanalysis) {
416 // AOD analysis
417 if (kUseMC)
418 ::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "MC usage disabled in analysis on AOD's");
419 kUseMC = kFALSE;
420 kUseTR = kFALSE;
421 if (iESDfilter)
422 ::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "ESD filter disabled in analysis on AOD's");
423 iESDfilter = 0;
424 if (iPhysicsSelection)
425 ::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "Physics Selection disabled in analysis on AOD's");
426 iPhysicsSelection = 0;
427 if (!iAODhandler) {
428 if (iJETAN)
429 ::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "JETAN disabled in analysis on AOD's without AOD handler");
430 iJETAN = 0;
431 }
432 if(iHMPID)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "HMPID analysis disabled in analysis on AOD's");
433 iHMPID = 0;
434 if(iHMPIDperf)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "HMPID performance disabled in analysis on AOD's");
435 iHMPIDperf = 0;
436 } else {
437 // ESD analysis
438 if (!kUseMC){
439 kUseTR = kFALSE;
440 if(kUseKinefilter)::Info("AnalysisTrainHMPID.C::CheckModuleFlags", "Kine Filter disabled in analysis without MC");
441 kUseKinefilter = kFALSE;
442 }
443 if (iJETAN){
444 iESDfilter=1;
445 }
446 if (!iESDfilter){
447 kUseKinefilter = kFALSE;
448 kUseMuonfilter = kFALSE;
449 }
66cdae53 450 }
451
452 iJETANLib = iJETAN && 1;
453 if (iESDfilter) {iAODhandler=1;}
454 if (kUseKinefilter && !kUseMC) kUseKinefilter = kFALSE;
455
456}
457
458
459//______________________________________________________________________________
460Bool_t Connect(const char *mode) {
461// Connect <username> to the back-end system.
462 Int_t imode = -1;
463 if (!strcmp(mode, "LOCAL")) imode = 0;
464 if (!strcmp(mode, "PROOF")) imode = 1;
465 if (!strcmp(mode, "GRID")) imode = 2;
466 TString username = gSystem->Getenv("alien_API_USER");
467 switch (imode) {
468 case 0:
469 break;
470 case 1:
471 if (!username.Length()) {
472 ::Error(Form("AnalysisTrainHMPID.C::Connect <%s>", mode), "Make sure you:\n \
473 1. Have called: alien-token-init <username>\n \
474 2. Have called: >source /tmp/gclient_env_$UID");
475 return kFALSE;
476 }
477 ::Info("AnalysisTrainHMPID.C::Connect", "Connecting user <%s> to PROOF cluster <%s>",
478 username.Data(), kProofCluster.Data());
479 gEnv->SetValue("XSec.GSI.DelegProxy", "2");
480 TProof::Open(Form("%s@%s", username.Data(), kProofCluster.Data()));
481 if (!gProof) {
482 if (strcmp(gSystem->Getenv("XrdSecGSISRVNAMES"), "lxfsrd0506.cern.ch"))
483 ::Error(Form("AnalysisTrainHMPID.C::Connect <%s>", mode), "Environment XrdSecGSISRVNAMES different from lxfsrd0506.cern.ch");
484 return kFALSE;
485 }
486 if(kProofClearPackages)gProof->ClearPackages();
487 break;
488 case 2:
489 if (!username.Length()) {
490 ::Error(Form("AnalysisTrainHMPID.C::Connect <%s>", mode), "Make sure you:\n \
491 1. Have called: alien-token-init <username>\n \
492 2. Have called: >source /tmp/gclient_env_$UID");
493 return kFALSE;
494 }
495 if (kPluginUse && !gSystem->Getenv("alien_CLOSE_SE")) {
496 ::Error(Form("AnalysisTrainHMPID.C::Connect <%s>", mode),
497 "When using the AliEn plugin it is preferable to define the \
498 variable alien_CLOSE_SE in your environment.");
499 return kFALSE;
500 }
501 ::Info("AnalysisTrainHMPID.C::Connect", "Connecting user <%s> to AliEn ...",
502 username.Data());
503 TGrid::Connect("alien://");
504 if (!gGrid || !gGrid->IsConnected()) return kFALSE;
505 break;
506 default:
507 ::Error("AnalysisTrainHMPID.C::Connect", "Unknown run mode: %s", mode);
508 return kFALSE;
509 }
510 ::Info("AnalysisTrainHMPID.C::Connect","Connected in %s mode", mode);
511 return kTRUE;
512}
513
514
515//______________________________________________________________________________
516Bool_t LoadCommonLibraries(const char *mode)
517{
518// Load common analysis libraries.
519 Int_t imode = -1;
520 if (!strcmp(mode, "LOCAL")) imode = 0;
521 if (!strcmp(mode, "PROOF")) imode = 1;
522 if (!strcmp(mode, "GRID")) imode = 2;
523 if (!gSystem->Getenv("ALICE_ROOT")) {
524 ::Error("AnalysisTrainHMPID.C::LoadCommonLibraries", "Analysis train requires that analysis libraries are compiled with a local AliRoot");
525 return kFALSE;
526 }
527 Bool_t success = kTRUE;
528 // ROOT libraries
529 gSystem->Load("libTree.so");
530 gSystem->Load("libGeom.so");
531 gSystem->Load("libVMC.so");
532 gSystem->Load("libPhysics.so");
533
534 // Load framework classes. Par option ignored here.
535 switch (imode) {
536 case 0:
537 case 2:
538 if (kUseCPAR) {
539 success &= LoadLibrary("STEERBase", mode, kTRUE);
540 success &= LoadLibrary("ESD", mode, kTRUE);
541 success &= LoadLibrary("AOD", mode, kTRUE);
542 success &= LoadLibrary("ANALYSIS", mode, kTRUE);
543 success &= LoadLibrary("ANALYSISalice", mode, kTRUE);
544 success &= LoadLibrary("CORRFW", mode, kTRUE);
545 } else {
546 success &= LoadLibrary("libSTEERBase.so", mode);
547 success &= LoadLibrary("libESD.so", mode);
548 success &= LoadLibrary("libAOD.so", mode);
549 success &= LoadLibrary("libANALYSIS.so", mode);
550 success &= LoadLibrary("libANALYSISalice.so", mode);
551 success &= LoadLibrary("libCORRFW.so", mode);
552 gROOT->ProcessLine(".include $ALICE_ROOT/include");
553 }
554 break;
555 case 1:
556 if (!kProofUseAFPAR) {
557 success &= LoadLibrary("STEERBase", mode);
558 success &= LoadLibrary("ESD", mode);
559 success &= LoadLibrary("AOD", mode);
560 success &= LoadLibrary("ANALYSIS", mode);
561 success &= LoadLibrary("ANALYSISalice", mode);
562 success &= LoadLibrary("CORRFW", mode);
563 } else {
564 success &= !gProof->EnablePackage(kProofAFversion);
565 success &= LoadLibrary("CORRFW", mode);
566 }
567 break;
568 default:
569 ::Error("AnalysisTrainHMPID.C::LoadCommonLibraries", "Unknown run mode: %s", mode);
570 return kFALSE;
571 }
572 if (success) {
573 ::Info("AnalysisTrainHMPID.C::LoadCommodLibraries", "Load common libraries: SUCCESS");
574 ::Info("AnalysisTrainHMPID.C::LoadCommodLibraries", "Include path for Aclic compilation:\n%s",
575 gSystem->GetIncludePath());
576 } else {
577 ::Info("AnalysisTrainHMPID.C::LoadCommodLibraries", "Load common libraries: FAILED");
578 }
579
580 return success;
581}
582
583
584//______________________________________________________________________________
585Bool_t LoadAnalysisLibraries(const char *mode)
586{
587// Load common analysis libraries.
588 Bool_t success = kTRUE;
589 if (iESDfilter) {
590 if (!LoadLibrary("PWG3base", mode, kTRUE) ||
591 !LoadLibrary("PWG3muon", mode, kTRUE)) return kFALSE;
592 }
593
594 if(iHMPID){
595 if (!LoadSource(Form("%s/HMPID/AliHMPIDAnalysisTask.cxx",gSystem->ExpandPathName("$ALICE_ROOT")), mode, kTRUE))return kFALSE;
596 }
8e6dfee0 597
598 if(iHMPIDperf){
599 if (!LoadSource(Form("%s/HMPID/AliHMPIDPerformanceTask.cxx",gSystem->ExpandPathName("$ALICE_ROOT")), mode, kTRUE))return kFALSE;
600 }
66cdae53 601
8e6dfee0 602 if(iHMPIDJets){
603 if (!LoadSource(Form("%s/HMPID/AliAnalysisTaskJetsHMPID.cxx",gSystem->ExpandPathName("$ALICE_ROOT")), mode, kTRUE))return kFALSE;
604 }
605
66cdae53 606 if (iJETANLib) {
607 if (!LoadLibrary("JETAN", mode, kTRUE)) return kFALSE;
608 }
609
610 ::Info("AnalysisTrainHMPID.C::LoadAnalysisLibraries", "Load other libraries: SUCCESS");
611 return kTRUE;
612}
613
614
615//______________________________________________________________________________
616Bool_t LoadLibrary(const char *module, const char *mode, Bool_t rec=kFALSE)
617{
618// Load a module library in a given mode. Reports success.
619 Int_t imode = -1;
620 Int_t result;
621 TString smodule(module);
622 if (!strcmp(mode, "LOCAL")) imode = 0;
623 if (!strcmp(mode, "PROOF")) imode = 1;
624 if (!strcmp(mode, "GRID")) imode = 2;
625 TString mod(module);
626 if (!mod.Length()) {
627 ::Error("AnalysisTrainHMPID.C::LoadLibrary", "Empty module name");
628 return kFALSE;
629 }
630 // If a library is specified, just load it
631 if (smodule.EndsWith(".so")) {
632 mod.Remove(mod.Index(".so"));
633 result = gSystem->Load(mod);
634 if (result < 0) {
635 ::Error("AnalysisTrainHMPID.C::LoadLibrary", "Could not load library %s", module);
636 return kFALSE;
637 }
638 if (rec) anaLibs += Form("%s.so ",mod.Data());
639 if (rec) anaLibsExtra += Form("%s.so ",mod.Data());
640 return kTRUE;
641 }
642 // Check if the library is already loaded
643 if (strlen(gSystem->GetLibraries(Form("%s.so", module), "", kFALSE)) > 0)
644 return kTRUE;
645 switch (imode) {
646 case 0:
647 case 2:
648 if (kUsePAR) {
649 result = SetupPar(module);
650 if (rec) anaPars += Form("%s.par ", module);
651 } else {
652 result = gSystem->Load(Form("lib%s.so", module));
653 if (rec) anaLibs += Form("lib%s.so ", module);
654 }
655 break;
656 case 1:
657 if(!gSystem->AccessPathName(module)){
658 ::Info("AnalysisTrainHMPID.C::LoadLibrary", "Removing directory %s",module);
659 gSystem->Exec(Form("rm -rf %s",module));
660 }
661 result = gProof->UploadPackage(module);
662 if (result<0) {
663 result = gProof->UploadPackage(gSystem->ExpandPathName(Form("$ALICE_ROOT/%s.par", module)));
664 if (result<0) {
665 ::Error("AnalysisTrainHMPID.C::LoadLibrary", "Could not find module %s.par in current directory nor in $ALICE_ROOT", module);
666 return kFALSE;
667 }
668 }
669 result = gProof->EnablePackage(module);
670 break;
671 default:
672 return kFALSE;
673 }
674 if (result < 0) {
675 ::Error("AnalysisTrainHMPID.C::LoadLibrary", "Could not load module %s", module);
676 return kFALSE;
677 }
678 return kTRUE;
679}
680
681//______________________________________________________________________________
682Bool_t LoadSource(const char *source, const char *mode, Bool_t rec=kFALSE)
683{
684// Load a module library in a given mode. Reports success.
685 Int_t imode = -1;
686 Int_t result = -1;
687 if (!strcmp(mode, "LOCAL")) imode = 0;
688 if (!strcmp(mode, "PROOF")) imode = 1;
689 if (!strcmp(mode, "GRID")) imode = 2;
690 TString ssource(source);
691 TString basename = gSystem->BaseName(ssource.Data());
692 if (!ssource.Length()) {
693 ::Error("AnalysisTrainHMPID.C::LoadSource", "Empty task name");
694 return kFALSE;
695 }
696 // we have a source code so compile it
697 if (ssource.EndsWith(".cxx")) {
698 // need to copy it here other wise the path is also used on grid...
699 ssource.Remove(ssource.Index(".cxx"));
700 basename.Remove(basename.Index(".cxx"));
701 Printf("LoadSources:: Copying... path %s{cxx,h}",ssource.Data());
702 gSystem->Exec(Form("cp %s.cxx . ",ssource.Data()));
703 gSystem->Exec(Form("cp %s.h . ",ssource.Data()));
704 // Path to code
705 // only needed for local compilation, in grid and proof mode
706 // the task headers are uploaded
707 // path.Remove(path.Index(gSystem->BaseName(path.Data())));
708 // Printf("LoadSources:: Including path %s",path.Data());
709 // if(path.Length()>0)gROOT->ProcessLine(Form(".include %s",path.Data()));
710 Printf("LoadSources:: Loading... path %s",basename.Data());
711 switch (imode) {
712 case 0:
713 result = gROOT->LoadMacro(Form("%s.cxx++g",basename.Data()));
714 break;
715 case 1:
716 result = gProof->Load(Form("%s.cxx++g",basename.Data()));
717 break;
718 case 2:
719 result = gROOT->LoadMacro(Form("%s.cxx++g",basename.Data()));
720 if (rec){
721 // what we want to compile
722 anaSources += Form("%s.cxx ",basename.Data());
723 // what we need as input...
724 anaLibs += Form("%s.cxx %s.h ",basename.Data(),basename.Data());
725 }
726 break;
727 default:
728 return kFALSE;
729 }
730 }
731 if (result < 0) {
732 ::Error("AnalysisTrainHMPID.C::LoadSources", "Could not load source %s", source);
733 return kFALSE;
734 }
735 return kTRUE;
736}
737
738//______________________________________________________________________________
739TChain *CreateChain(const char *mode, const char *plugin_mode)
740{
741// Create the input chain
742 Int_t imode = -1;
743 if (!strcmp(mode, "LOCAL")) imode = 0;
744 if (!strcmp(mode, "PROOF")) imode = 1;
745 if (!strcmp(mode, "GRID")) imode = 2;
746 TChain *chain = NULL;
747 // Local chain
748 switch (imode) {
749 case 0:
8e6dfee0 750 if (iAODanalysis) {
751 if (!kLocalXMLDataset.Length()) {
752 // Local AOD
753 chain = new TChain("aodTree");
754 TString line;
755 ifstream in;
756 in.open(kLocalDataList.Data());
757 while (in.good()) {
758 in >> line;
759 if (line.Length() == 0) continue;
760 // cout << " line = " << line << endl;
761 chain->Add(line.Data());
762 }
763 } else {
764 // Interactive AOD
765 chain = CreateChainSingle(kLocalXMLDataset, "aodTree");
766 }
767 } else {
768 if (!kLocalXMLDataset.Length()) {
769 // Local ESD
770 chain = new TChain("esdTree");
771 TString line;
772 ifstream in;
773 in.open(kLocalDataList.Data());
774 while (in.good()) {
775 in >> line;
776 if (line.Length() == 0) continue;
777 cout << " line = " << line << endl;
778 chain->Add(line.Data());
779 }
780 } else {
781 // Interactive ESD
782 chain = CreateChainSingle(kLocalXMLDataset, "esdTree");
783 }
784 }
66cdae53 785 break;
786 case 1:
787 break;
788 case 2:
789 if (kPluginUse) {
790 AliAnalysisGrid *alienHandler = CreateAlienHandler(plugin_mode);
791 AliAnalysisManager::GetAnalysisManager()->SetGridHandler(alienHandler);
792 } else {
8e6dfee0 793 TString treeName = "esdTree";
794 if (iAODanalysis) treeName = "aodTree";
66cdae53 795 chain = CreateChainSingle("wn.xml", treeName);
796 }
797 break;
798 default:
799 }
800 if (chain && chain->GetNtrees()) return chain;
801 return NULL;
802}
803
804//______________________________________________________________________________
805TChain* CreateChainSingle(const char* xmlfile, const char *treeName)
806{
807 printf("*******************************\n");
808 printf("*** Getting the ESD Chain ***\n");
809 printf("*******************************\n");
810 TAlienCollection * myCollection = TAlienCollection::Open(xmlfile);
811
812 if (!myCollection) {
813 ::Error("AnalysisTrainHMPID.C::CreateChainSingle", "Cannot create an AliEn collection from %s", xmlfile) ;
814 return NULL ;
815 }
816
817 TChain* chain = new TChain(treeName);
818 myCollection->Reset() ;
819 while ( myCollection->Next() ) chain->Add(myCollection->GetTURL("")) ;
820 chain->ls();
821 return chain;
822}
823
824//______________________________________________________________________________
825Int_t SetupPar(char* pararchivename)
826{
827 if (!pararchivename || !strlen(pararchivename)) return -1;
828 char processline[1024];
829 if (gSystem->AccessPathName(Form("%s.par", pararchivename))) {
830 if (!gSystem->AccessPathName(Form("%s/%s.par", gSystem->Getenv("ALICE_ROOT"),pararchivename))) {
831 ::Info("AnalysisTrainHMPID.C::SetupPar", "Getting %s.par from $ALICE_ROOT", pararchivename);
832 TFile::Cp(gSystem->ExpandPathName(Form("$ALICE_ROOT/%s.par", pararchivename)),
833 Form("%s.par",pararchivename));
834 } else {
835 ::Error("AnalysisTrainHMPID.C::SetupPar", "Cannot find %s.par", pararchivename);
836 return -1;
837 }
838 }
839 gSystem->Exec(Form("tar xvzf %s.par", pararchivename));
840
841 TString ocwd = gSystem->WorkingDirectory();
842 if (!gSystem->ChangeDirectory(pararchivename)) return -1;
843
844 // check for BUILD.sh and execute
845 if (!gSystem->AccessPathName("PROOF-INF/BUILD.sh")) {
846 printf("*******************************\n");
847 printf("*** Building PAR archive ***\n");
848 printf("*******************************\n");
849 if (gSystem->Exec("PROOF-INF/BUILD.sh")) {
850 Error("runProcess","Cannot Build the PAR Archive! - Abort!");
851 return -1;
852 }
853 }
854
855 // check for SETUP.C and execute
856 if (!gSystem->AccessPathName("PROOF-INF/SETUP.C")) {
857 printf("*******************************\n");
858 printf("*** Setup PAR archive ***\n");
859 printf("*******************************\n");
860 gROOT->Macro("PROOF-INF/SETUP.C");
861 }
862 if (!gSystem->ChangeDirectory(ocwd.Data())) return -1;
863 return 0;
864}
865
866//______________________________________________________________________________
867AliAnalysisAlien* CreateAlienHandler(const char *plugin_mode)
868{
869// Check if user has a valid token, otherwise make one. This has limitations.
870// One can always follow the standard procedure of calling alien-token-init then
871// source /tmp/gclient_env_$UID in the current shell.
872 if (!AliAnalysisGrid::CreateToken()) return NULL;
873 AliAnalysisAlien *plugin = new AliAnalysisAlien();
874// Set the run mode (can be "full", "test", "offline", "submit" or "terminate")
875 plugin->SetRunMode(plugin_mode);
876 if (kPluginUseProductionMode) plugin->SetProductionMode();
877 plugin->SetJobTag(kJobTag);
636bde73 878 plugin->SetNtestFiles(1);
66cdae53 879// plugin->SetPreferedSE("ALICE::NIHAM::File");
880// Set versions of used packages
881 plugin->SetAPIVersion("V1.1x");
882 plugin->SetROOTVersion(kPluginRootVersion);
883 plugin->SetAliROOTVersion(kPluginAliRootVersion);
884
885// Declare input data to be processed.
886// Method 1: Create automatically XML collections using alien 'find' command.
887// Define production directory LFN
888 plugin->SetGridDataDir(kGridDatadir.Data());
889// Set data search pattern
8e6dfee0 890 if (iAODanalysis) plugin->SetDataPattern(" *AliAOD.root");
891 else plugin->SetDataPattern(Form(" %s/*/*ESDs.root",kGridPassPattern.Data()));
66cdae53 892// ...then add run numbers to be considered
8e6dfee0 893 plugin->SetRunPrefix("000"); // if real data
66cdae53 894 plugin->SetRunRange(kGridRunRange[0], kGridRunRange[1]);
895
896 if(kGridLocalRunList.Length()>0){
897 ifstream in1;
898 in1.open(kGridLocalRunList.Data());
899 int iRun;
900 // just use run numbers, negatives will be excluded
901 while(in1>>iRun){
902 if(iRun>0){
903 Printf("AnalysisTrainHMPID Adding run number from File %s", Form(kGridRunPattern.Data(),iRun));
904 plugin->AddRunNumber(Form(kGridRunPattern.Data(),iRun));
905 } else{
906 Printf("AnalysisTrainHMPID Skipping run number from File %d", iRun);
907 }
908 }
909 }
910
911// Method 2: Declare existing data files (raw collections, xml collections, root file)
912// If no path mentioned data is supposed to be in the work directory (see SetGridWorkingDir())
913// XML collections added via this method can be combined with the first method if
914// the content is compatible (using or not tags)
915// plugin->AddDataFile("Hijing.xml");
916// plugin->AddDataFile("/alice/data/2008/LHC08c/000057657/raw/Run57657.Merged.RAW.tag.root");
917// Define alien work directory where all files will be copied. Relative to alien $HOME.
918 TString alien_workdir = "";
919
920 alien_workdir += kGridWorkDir.Data();
921 if(kGridDataSet.Length()>0)alien_workdir += Form("/%s",kGridDataSet.Data());
922 plugin->SetGridWorkingDir(alien_workdir.Data());
923
924 // Declare alien output directory. Relative to working directory.
925 if (!kGridOutdir.Length()) kGridOutdir = Form("output_%s",kTrainName.Data());
926 plugin->SetGridOutputDir(kGridOutdir);
927
928 // set extra libs before par file compilation
929 anaLibs += kGridExtraFiles;
930 anaLibs = anaLibs.Strip();
931 Printf("anaLibs %s",anaLibs.Data());
932 Printf("anaLibsExtra %s",anaLibsExtra.Data());
933
934 if (anaLibs.Length()) plugin->SetAdditionalLibs(anaLibs.Data());
935 if (anaLibsExtra.Length()) plugin->SetAdditionalRootLibs(anaLibsExtra.Data());
936
937 TString ana_sources = "";
938 TString ana_add = "";
939 if (kUsePAR && anaPars.Length()) {
940 printf("%s\n", anaPars.Data());
941 TObjArray *arr;
942 TObjString *objstr;
943 arr = anaPars.Tokenize(" ");
944 TIter next(arr);
945 while ((objstr=(TObjString*)next())) plugin->EnablePackage(objstr->GetString());
946 delete arr;
947 }
948
949// Declare the analysis source files names separated by blancs. To be compiled runtime
950// using ACLiC on the worker nodes.
951 ana_sources = anaSources.Strip();
952// Declare all libraries (other than the default ones for the framework. These will be
953// loaded by the generated analysis macro. Add all extra files (task .cxx/.h) here.
954
955 if (ana_sources.Length()) plugin->SetAnalysisSource(ana_sources);
636bde73 956 plugin->SetExecutableCommand(kPluginExecutableCommand.Data());
66cdae53 957 // Declare the output file names separated by blancs.
958 // (can be like: file.root or file.root@ALICE::Niham::File)
636bde73 959 plugin->SetUseSubmitPolicy(kFALSE);
66cdae53 960 plugin->SetMergeExcludes(kGridMergeExclude);
961 plugin->SetMaxMergeFiles(kGridMaxMergeFiles);
8e6dfee0 962 plugin->SetMaxMergeStages(kGridMaxMergeStages);
66cdae53 963 plugin->SetNrunsPerMaster(kGridRunsPerMaster);
964 plugin->SetMergeViaJDL(kPluginMergeViaJDL);
965 // Use fastread option
966 plugin->SetFastReadOption(kPluginFastReadOption);
967 // UseOverwrite mode
636bde73 968 plugin->SetOverwriteMode(kPluginOverwriteMode);
66cdae53 969 // Optionally define the files to be archived.
970 // plugin->SetOutputArchive("log_archive.zip:stdout,stderr@ALICE::NIHAM::File root_archive.zip:AliAOD.root,AOD.tag.root@ALICE::NIHAM::File");
971 plugin->SetOutputToRunNo(kPluginOutputToRunNumber); // write the output to subdirs named after run number
972// plugin->SetDefaultOutputs(kFALSE);
973
974 // Put default output files to archive
975 TString listhists = "";
976 TString listaods = "";
977 AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
978 TIter next(mgr->GetOutputs());
979 AliAnalysisDataContainer *output;
980 while ((output=(AliAnalysisDataContainer*)next())) {
981 const char *filename = output->GetFileName();
982 if (!(strcmp(filename, "default"))) {
983 if (!mgr->GetOutputEventHandler()) continue;
984 filename = mgr->GetOutputEventHandler()->GetOutputFileName();
985 if (listaods.Length()) listaods += " ";
986 listaods += filename;
987 } else {
988 if(!listhists.Contains(filename)){
989 if (listhists.Length()) listhists += " ";
990 listhists += filename;
991 }
992 }
993 }
994
995 if (mgr->GetExtraFiles().Length()) {
996 if (listaods.Length()) listaods += " ";
997 listaods += mgr->GetExtraFiles();
998 }
999
1000 TString outputArchive;
1001 outputArchive = Form("log_archive.zip:std*r@%s",kGridOutputStorages.Data());
1002 listaods.ReplaceAll(" ", ",");
1003 listhists.ReplaceAll(" ", ",");
1004 if (listhists.Length()) listhists = Form("hist_archive.zip:%s@%s", listhists.Data(), kGridOutputStorages.Data());
1005 if (listaods.Length()) listaods = Form("aod_archive.zip:%s@%s", listaods.Data(), kGridOutputStorages.Data());
1006
1007 if (!listhists.Length() && !listaods.Length()) {
1008 ::Fatal("AnalysisTrainHMPID", "No task output !");
1009 }
636bde73 1010
66cdae53 1011 if (listaods.Length()) {
1012 outputArchive += " ";
1013 outputArchive += listaods;
636bde73 1014 }
66cdae53 1015 if (listhists.Length()) {
1016 outputArchive += " ";
1017 outputArchive += listhists;
636bde73 1018 }
66cdae53 1019// plugin->SetOutputArchive(outputArchive);
1020
1021// Optionally set a name for the generated analysis macro (default MyAnalysis.C)
1022 plugin->SetAnalysisMacro(Form("%s.C", kTrainName.Data()));
1023// Optionally set maximum number of input files/subjob (default 100, put 0 to ignore)
1024 plugin->SetSplitMaxInputFileNumber(kGridFilesPerJob);
1025// Optionally set number of failed jobs that will trigger killing waiting sub-jobs.
1026// plugin->SetMaxInitFailed(5);
1027// Optionally resubmit threshold.
1028// plugin->SetMasterResubmitThreshold(90);
1029// Optionally set time to live (default 30000 sec)
1030 plugin->SetTTL(30000);
1031// Optionally set input format (default xml-single)
1032 plugin->SetInputFormat("xml-single");
1033// Optionally modify the name of the generated JDL (default analysis.jdl)
1034 plugin->SetJDLName(Form("%s.jdl", kTrainName.Data()));
1035// Optionally modify the executable name (default analysis.sh)
1036 plugin->SetExecutable(Form("%s.sh", kTrainName.Data()));
1037// Optionally modify job price (default 1)
1038 plugin->SetPrice(1);
1039// Optionally modify split mode (default 'se')
1040 plugin->SetSplitMode("se");
1041 plugin->SetCheckCopy(kFALSE);
1042 return plugin;
1043}
1044
1045//______________________________________________________________________________
1046Bool_t LoadConfig(const char *filename)
1047{
1048// Read train configuration from file
1049 if (gSystem->AccessPathName(filename)) {
1050 ::Error("AnalysisTrainHMPID.C::LoadConfig", "Config file name not found");
1051 return kFALSE;
1052 }
1053 gROOT->ProcessLine(Form(".x %s", filename));
1054 ::Info("AnalysisTrainHMPID.C::LoadConfig", "Train configuration loaded from file %s", filename);
1055 return kTRUE;
1056}
1057
1058//______________________________________________________________________________
1059Bool_t PatchJDL(){
1060 Printf(">>> Patching JDL");
1061 AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
1062 AliAnalysisAlien* gridHandler = (AliAnalysisAlien*)mgr->GetGridHandler();
1063 TGridJDL *jdl = gridHandler->GetGridJDL();
1064 if(iJETAN)jdl->AddToPackages("fastjet","v2.4.0");
1065 gridHandler->WriteJDL(kFALSE);
1066 Printf("<<< Patching JDL");
1067 return kTRUE;
1068}
1069
1070//______________________________________________________________________________
1071Bool_t PatchAnalysisMacro(){
1072 Printf(">>> Patching AnalysisMacro");
1073 gSystem->Exec(Form("mv %s.C %s.C_tmp",kTrainName.Data(),kTrainName.Data()));
1074
1075 ifstream in1;
1076 in1.open(Form("%s.C_tmp", kTrainName.Data()));
1077 char cLine[250];
1078 TString st;
1079 while(in1.getline(cLine,250)){
1080 st += cLine;
1081 st += "\n";
1082 }
1083 Int_t index= -1;
1084 index = st.Index("gSystem->Load(\"libPhysics\");");
1085 index += strlen("gSystem->Load(\"libPhysics\");");
1086 /*
1087 TObjArray *arr;
1088 TObjString *objstr;
1089 arr = anaLibs.Tokenize(" ");
1090 TIter next(arr);
1091
1092 add += "\n\n // added by CKB \n";
1093 while ((objstr=(TObjString*)next())){
1094 if(objstr->GetString().Contains("PWG3"))continue;
1095 if(objstr->GetString().EndsWith(".so"))add += Form("gSystem->Load(\"%s\");\n",objstr->GetString().Data());
1096 }
1097 delete arr;
1098 */
1099 // add += Form("AliLog::SetGlobalLogLevel(%d);\n",AliLog::GetGlobalLogLevel());
1100 TString add = "";
1101
1102 if(index<0)Printf("%s:%d index out of bounds",(char*)__FILE__,__LINE__);
1103 add += "\n\n // added by CKB \n";
1104 add += "\n gSystem->AddIncludePath(\"./\"); \n";
1105 if(gGrid && kPluginAliRootVersion.Length()==0){
1106 add += "\n // Dirty hack for TRD reference data \n";
1107 add += "\n gSystem->Setenv(\"ALICE_ROOT\",\"";
1108 add += Form("alien://%s/rootfiles/",gGrid->GetHomeDirectory());
1109 add += "\"); \n";
1110 }
1111 add += "// BKC \n\n";
1112 st.Insert(index,add.Data());
1113
1114 if(kUseCPAR && kPluginAliRootVersion.Length()==0){
1115 index = st.Index("gSystem->AddIncludePath(\"-I$"); // uncommen $ALICE_ROOT include for par files
1116 if(index<0)Printf("%s:%d index out of bounds",(char*)__FILE__,__LINE__);
1117 st.Insert(index,"// CKB comment out whehn no aliroot is provided \n //");
1118 }
1119
1120 ofstream out;
1121 out.open(Form("%s.C", kTrainName.Data()));
1122 if (out.bad()) {
1123 return kFALSE;
1124 }
1125 out << st << endl;
1126 Printf("<<< Patching AnalysisMacro");
1127
1128 Printf(">>> Patching Merge Macro");
1129 gSystem->Exec(Form("mv %s_merge.C %s_merge.C_tmp",kTrainName.Data(),kTrainName.Data()));
1130
1131 ifstream in2;
1132 in2.open(Form("%s_merge.C_tmp", kTrainName.Data()));
1133 TString st2;
1134 while(in2.getline(cLine,250)){
1135 st2 += cLine;
1136 st2 += "\n";
1137 }
1138 index = st2.Index("gSystem->Load(\"libPhysics\");");
1139 index += strlen("gSystem->Load(\"libPhysics\");");
1140 TString add2 = "";
1141 add2 += "\n gSystem->AddIncludePath(\"./\"); \n";
1142 if(gGrid&&kPluginAliRootVersion.Length()==0){
1143 add2 += "\n // Dirty hack for TRD reference data \n";
1144 add2 += "\n gSystem->Setenv(\"ALICE_ROOT\",\"";
1145 add2 += Form("alien://%s/rootfiles/",gGrid->GetHomeDirectory());
1146 add2 += "\"); \n";
1147 }
1148 add2 += "// BKC \n\n";
1149 if(index<0)Printf("%s:%d index out of bounds",(char*)__FILE__,__LINE__);
1150 st2.Insert(index,add.Data());
1151
1152 if(kUseCPAR&&kPluginAliRootVersion.Length()==0){
1153 index = st2.Index("gSystem->AddIncludePath(\"-I$"); // uncommen $ALICE_ROOT include for par files
1154 if(index<0)Printf("%s:%d index out of bounds",(char*)__FILE__,__LINE__);
1155 st2.Insert(index,"// CKB comment out whehn no aliroot is provided \n //");
1156 }
1157
1158 // do not exclude the extra files from merign, this is done explicitly in this train script
1159 index = st2.Index("mergeExcludes +="); // uncommen $ALICE_ROOT include for par files
1160 if(index<0)Printf("%s:%d index out of bounds",(char*)__FILE__,__LINE__);
1161 st2.Insert(index,"// CKB comment out, handled explicitly by the train macro \n //");
1162
1163
1164 ofstream out2;
1165 out2.open(Form("%s_merge.C", kTrainName.Data()));
1166 if (out2.bad()) {
1167 return kFALSE;
1168 }
1169 out2 << st2 << endl;
1170 Printf("<<< Patching Merging Macro");
1171
1172
1173 return kTRUE;
1174
1175}