update config objects for MultiplicityCorrelations
[u/mrichter/AliRoot.git] / HMPID / AnalysisTrainHMPID.C
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
18 TString     kTrainName         = "hmpidAnalysis"; // (no blancs or special characters)
19 TString     kJobTag            = "HMPID Tasks analysis train configured"; //
20 Bool_t      kUsePAR            = kFALSE;  // use par files for extra libs
21 Bool_t      kUseCPAR           = kFALSE;  // use par files for common libs
22 Bool_t      kFillAOD           = kFALSE;  // switch of AOD filling for on the fly analysis
23
24 Int_t       iAODanalysis       = 0;      // Analysis on input AOD's
25 Int_t       iAODhandler        = 1;      // Analysis produces an AOD or dAOD's
26 Int_t       iESDfilter         = 0;      // ESD to AOD filter (barrel + muon tracks)
27 Int_t       iPhysicsSelection  = 1;      // Physics selection task
28 Int_t       iCentrality        = 0;      // Physics selection task
29 Bool_t      kUseKinefilter     = kFALSE; // use Kinematics filter
30 Bool_t      kUseMuonfilter     = kFALSE; // use muon filter
31 TString     kCommonOutputFileName = "HmpidOutput.root";
32
33
34 //== general process variables
35
36 // ### Other flags to steer the analysis
37 //==============================================================================
38 Bool_t      kSkipTerminate      = kFALSE; // Do not call Teminate
39 Bool_t      kDebugLevel         = kTRUE; // activate debugging
40 Int_t       kUseSysInfo         = 0; // activate debugging
41 Long64_t    kNumberOfEvents     = 1234567890; // number of events to process from the chain
42 Bool_t      kUseMC              = kFALSE;  // use MC info
43 Bool_t      kIsMC               = kFALSE;  // is MC info, if false it overwrites Use(AOD)MC
44 Bool_t      kUseESDTags         = kFALSE;  // use ESD tags for selection
45 Bool_t      kUseTR              = kFALSE;  // use track references
46
47 // ### Analysis modules to be included. Some may not be yet fully implemented.
48 //==============================================================================
49 Int_t       iHMPID             = 1;      // Basic HMPID analysis task
50 Int_t       iHMPIDperf         = 0;      // Basic HMPID performance task
51 Int_t       iJETAN             = 0;      // Jet analysis (PWG4) // 1 write standard 2 write non-standard jets
52 Int_t       iHMPIDJets         = 0;      // Jet chemistry with HMPID
53 Int_t       iJETANLib          = 0;
54 Int_t       kHighPtFilterMask  = 16;     // change depending on the used AOD Filter
55
56
57 //==============================================================================
58 // ### PROOF Steering varibales
59 //==============================================================================
60 //== proof setup variables
61 TString     kProofCluster      = "alice-caf.cern.ch";
62 Bool_t      kProofUseAFPAR     = kTRUE;  // use AF special par file
63 TString     kProofAFversion    = "VO_ALICE@AliRoot::v4-20-08-AN";
64 //== proof input and output variables
65 TString     kProofDataSet      = "/alice/sim/LHC10d2_117220";
66 //== proof process variables
67 Bool_t      kProofClearPackages = kFALSE;
68 Int_t       kProofEvents = 10000;
69 Int_t       kProofOffset = 0;
70
71 //==============================================================================
72 // ### Grid plugin Steering varibiables
73 //==============================================================================
74 //== grid plugin setup variables
75 Bool_t      kPluginUse         = kTRUE;   // do not change
76 Bool_t      kPluginUseProductionMode  = kFALSE;   // use the plugin in production mode
77 TString     kPluginRootVersion       = "v5-28-00d";  // *CHANGE ME IF MORE RECENT IN GRID*
78 TString     kPluginAliRootVersion    = "v4-21-26-AN";  // *CHANGE ME IF MORE RECENT IN GRID*                                          
79 Bool_t      kPluginMergeViaJDL       = kTRUE;  // merge via JDL
80 Bool_t      kPluginFastReadOption    = kFALSE;  // use xrootd flags to reduce timeouts
81 Bool_t      kPluginOverwriteMode     = kTRUE;  // overwrite existing collections
82 Int_t       kPluginOutputToRunNumber = 1;     // write the output to subdirs named after run number
83 TString kPluginExecutableCommand = "aliroot -b -q";
84
85 // == grid plugin input and output variables
86 TString     kGridDatadir      = "/alice/data/2010/LHC10e";
87 TString     kGridLocalRunList = "";
88 TString     kGridWorkDir      = "";   // Alien working directory
89 TString     kGridOutdir       = ""; // AliEn output directory. If blank will become output_<kTrainName>
90 TString     kGridDataSet      = ""; // sub working directory not to confuse different run xmls 
91 Int_t       kGridRunRange[2]       = {128260,128260}; // Set the run range
92 TString     kGridRunPattern        = "%03d"; // important for leading zeroes!!
93 TString     kGridPassPattern       = "/ESDs/pass2";
94 TString     kGridExtraFiles        = ""; // files that will be added to the input list in the JDL...
95 Int_t       kGridMaxMergeFiles      = 12; // Number of files merged in a chunk grid run range
96 Int_t       kGridMaxMergeStages     = 3;  // Number of stages in the merging procedure
97 TString     kGridMergeExclude       = "AliAOD.root"; // Files that should not be merged
98 TString     kGridOutputStorages      = "disk=2"; // Make replicas on the storages
99 // == grid process variables
100 Int_t       kGridRunsPerMaster     = 1; // Number of runs per master job
101 Int_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
108 TString     kLocalXMLDataset   = ""; // Change local xml dataset for local interactive analysis
109 TString     kLocalDataList   = "local_deltaaod.txt"; // Change local xml dataset for local interactive analysis
110 // == local process variables
111
112
113
114 // Temporaries.
115 TString anaPars = "";
116 TString anaLibs = "";
117 TString anaLibsExtra = "";
118 TString anaSources = "";
119 // Function signatures
120 class AliAnalysisAlien;
121
122 //______________________________________________________________________________
123 void 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");
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");
145    if (iESDfilter)   printf("=  ESD filter                                                    =\n");
146    if (iJETAN)       printf("=  Jet analysis                                                  =\n");
147    if (iHMPID)       printf("=  HMPID generic                                                 =\n");
148    if (iHMPIDperf)   printf("=  HMPID performance                                             =\n");
149    if (iHMPIDJets)   printf("=  HMPID Jet chemistry                                           =\n");
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
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)
188    if (iAODanalysis) {
189    // AOD input handler
190       AliAODInputHandler *aodH = new AliAODInputHandler();
191       mgr->SetInputEventHandler(aodH);
192    } else {
193    // ESD input handler
194       AliESDInputHandler *esdHandler = new AliESDInputHandler();
195       if (kUseESDTags) esdHandler->SetReadTags();
196       esdHandler->SetReadFriends(kTRUE);
197       mgr->SetInputEventHandler(esdHandler);
198    }
199
200    // Monte Carlo handler
201    if (kUseMC && !iAODanalysis) {
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.
240    if(iPhysicsSelection && !iAODanalysis){
241      gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
242      AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(kIsMC,kTRUE,kTRUE); // last flag also adds information on  
243    }
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    }     
250
251    if (iESDfilter && !iAODanalysis) {
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);
273      if (!taskHmpid) ::Warning("AnalysisTrainHMPID", "AliHMPIDAnalysisTask cannot run for this train conditions - EXCLUDED");
274    }
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    
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 //______________________________________________________________________________
345 void 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          }
358          mgr->StartAnalysis(mode, chain, kNumberOfEvents);
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 //______________________________________________________________________________
386 void 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){
410       // switch off anything related to MC
411       kUseMC = kFALSE;
412       kUseTR = kFALSE;
413    }
414
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       }
450    }
451
452    iJETANLib = iJETAN && 1;
453    if (iESDfilter) {iAODhandler=1;}
454    if (kUseKinefilter && !kUseMC) kUseKinefilter = kFALSE;
455    
456 }
457
458
459 //______________________________________________________________________________
460 Bool_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 //______________________________________________________________________________
516 Bool_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 //______________________________________________________________________________
585 Bool_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    }
597    
598    if(iHMPIDperf){
599      if (!LoadSource(Form("%s/HMPID/AliHMPIDPerformanceTask.cxx",gSystem->ExpandPathName("$ALICE_ROOT")), mode, kTRUE))return kFALSE;
600    }   
601
602    if(iHMPIDJets){
603      if (!LoadSource(Form("%s/HMPID/AliAnalysisTaskJetsHMPID.cxx",gSystem->ExpandPathName("$ALICE_ROOT")), mode, kTRUE))return kFALSE;
604    }
605    
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 //______________________________________________________________________________
616 Bool_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 //______________________________________________________________________________
682 Bool_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 //______________________________________________________________________________
739 TChain *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:
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          }
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 {
793             TString           treeName = "esdTree";
794             if (iAODanalysis) treeName = "aodTree";
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 //______________________________________________________________________________
805 TChain* 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 //______________________________________________________________________________
825 Int_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 //______________________________________________________________________________
867 AliAnalysisAlien* 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);
878    plugin->SetNtestFiles(1);
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
890    if (iAODanalysis) plugin->SetDataPattern(" *AliAOD.root");
891    else plugin->SetDataPattern(Form(" %s/*/*ESDs.root",kGridPassPattern.Data()));
892 // ...then add run numbers to be considered
893    plugin->SetRunPrefix("000"); // if real data
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);
956    plugin->SetExecutableCommand(kPluginExecutableCommand.Data());
957    // Declare the output file names separated by blancs.
958    // (can be like: file.root or file.root@ALICE::Niham::File)
959    plugin->SetUseSubmitPolicy(kFALSE);
960    plugin->SetMergeExcludes(kGridMergeExclude);
961    plugin->SetMaxMergeFiles(kGridMaxMergeFiles);
962    plugin->SetMaxMergeStages(kGridMaxMergeStages);
963    plugin->SetNrunsPerMaster(kGridRunsPerMaster);
964    plugin->SetMergeViaJDL(kPluginMergeViaJDL);
965    // Use fastread option
966    plugin->SetFastReadOption(kPluginFastReadOption);
967    // UseOverwrite mode
968    plugin->SetOverwriteMode(kPluginOverwriteMode);
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    }
1010
1011    if (listaods.Length()) {
1012       outputArchive += " ";
1013       outputArchive += listaods;
1014    }
1015    if (listhists.Length()) {
1016       outputArchive += " ";
1017       outputArchive += listhists;
1018    }
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 //______________________________________________________________________________
1046 Bool_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 //______________________________________________________________________________
1059 Bool_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 //______________________________________________________________________________
1071 Bool_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 }