Do not include from subdirectories
[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 (PWGJE) // 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-33-02b";  // *CHANGE ME IF MORE RECENT IN GRID*
78 TString     kPluginAliRootVersion    = "v5-03-31-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       = 50; // 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(kFALSE);
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/OADB/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/OADB/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 jet analysis is included, better use the following macro with kHighPtFilterMask=272
256 /*      gROOT->LoadMacro("$ALICE_ROOT/PWGJE/macros/AddTaskESDFilterPWGJETrain.C");
257       AliAnalysisTaskESDfilter *taskesdfilter = AddTaskESDFilterPWGJETrain(kUseKinefilter,kUseMuonfilter);
258       taskesdfilter->DisableV0s();
259       taskesdfilter->DisableCascades();
260       taskesdfilter->DisableKinks();
261       taskesdfilter->DisablePmdClusters();
262       taskesdfilter->DisableCaloClusters();
263       taskesdfilter->DisableCells();*/
264       if(kIsMC){
265          mgr->RegisterExtraFile("pyxsec_hists.root");
266          if(kGridMergeExclude.Length())kGridMergeExclude += " ";
267          kGridMergeExclude += "pyxsec_hists.root";
268       }
269    }   
270
271     // Jet analysis
272    if (iJETAN) {
273       gROOT->LoadMacro("$ALICE_ROOT/PWGJE/macros/AddTaskJets.C");
274       AliAnalysisTaskJets *taskjets = 0;
275       if (iJETAN&1) taskjets = AddTaskJets("AOD","FASTJET",0.4,kHighPtFilterMask); 
276       if (!taskjets) ::Warning("AnalysisTrainHMPID", "AliAnalysisTaskJets cannot run for this train conditions - EXCLUDED");
277    }
278
279    if(iHMPID){
280      gROOT->LoadMacro("$ALICE_ROOT/HMPID/AddTaskHMPID.C");
281      AliHMPIDAnalysisTask *taskHmpid = AddTaskHMPID(kUseMC);
282      if (!taskHmpid) ::Warning("AnalysisTrainHMPID", "AliHMPIDAnalysisTask cannot run for this train conditions - EXCLUDED");
283    }
284    
285    if(iHMPIDperf){
286      gROOT->LoadMacro("$ALICE_ROOT/HMPID/AddTaskHMPIDPerformance.C");
287      AliHMPIDPerformanceTask *taskHmpidPerformance = AddTaskHMPIDPerformance(kUseMC);
288      if (!taskHmpidPerformance) ::Warning("AnalysisTrainHMPID", "AliHMPIDPerformanceTask cannot run for this train conditions - EXCLUDED");
289    }
290       
291    if(iHMPIDJets){
292      gROOT->LoadMacro("$ALICE_ROOT/HMPID/AddTaskJetsHMPID.C");
293      AliAnalysisTaskJetsHMPID *taskHmpidJets = AddTaskJetsHMPID("jetsAOD_FASTJET04_B0_Filter00272_Cut00150","jeteventbackground_clustersAOD_KT04_B0_Filter00256_Cut00150_Skip00");
294      if (!taskHmpidJets) ::Warning("AnalysisTrainHMPID", "AliAnalysisTaskJetsHMPID cannot run for this train conditions - EXCLUDED");
295    }
296    
297    if (kPluginUse) {
298       AliAnalysisGrid *alienHandler = CreateAlienHandler(plugin_mode);
299       AliAnalysisManager::GetAnalysisManager()->SetGridHandler(alienHandler);
300    }
301
302    if (mgr->InitAnalysis()) {
303      mgr->PrintStatus();
304      if (!strcmp(plugin_mode,"submit") && smode=="GRID"){
305        TString alien_workdir = gGrid->GetHomeDirectory();
306        alien_workdir += kGridWorkDir.Data();
307        if(kGridDataSet.Length()>0)alien_workdir += Form("/%s",kGridDataSet.Data());
308        AliAnalysisAlien *gridhandler = (AliAnalysisAlien*)mgr->GetGridHandler();
309        printf("=== AnalysisTrainHMPID:: Registering jdl in the work directory alien://%s/%s, should be done by the manager! ===\n",
310               alien_workdir.Data(),gridhandler->GetGridOutputDir());
311
312        TString dest;
313        dest = Form("%s/%s/%s.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.jdl",kTrainName.Data()),Form("alien://%s",dest.Data()));
319
320
321        TString dest;
322        dest = Form("%s/%s/%s_merge.jdl",alien_workdir.Data(),gridhandler->GetGridOutputDir(),kTrainName.Data());
323        if(AliAnalysisAlien::FileExists(dest.Data())){
324          //      Printf("%s exist on grid removing...",dest.Data());
325          //      gGrid->Rm(dest.Data());
326        }
327        TFile::Cp(Form("file:%s_merge.jdl",kTrainName.Data()),Form("alien://%s",dest.Data()));
328      }
329
330      AliLog::SetGlobalLogLevel(AliLog::kError);
331      if((kUseSysInfo>0 && smode=="LOCAL") || !strcmp(plugin_mode, "test")){
332        TFile *fM = TFile::Open("manager_local.root","RECREATE");
333        mgr->Write();
334        fM->Close();
335      }
336
337      StartAnalysis(smode, chain);
338        
339      if((kUseSysInfo>0 && smode=="LOCAL") || !strcmp(plugin_mode, "test")){
340        for(int i = 0;i < mgr->GetTopTasks()->GetEntries();i++){
341          mgr->ProfileTask(i);
342        }
343      }
344      if (!strcmp(plugin_mode, "offline") && smode=="GRID"){
345        // Offline mode path files
346        //       PatchJDL();
347        PatchAnalysisMacro();
348      }
349    }
350 }
351
352
353 //______________________________________________________________________________
354 void StartAnalysis(const char *mode, TChain *chain) {
355
356    Int_t imode = -1;
357    AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
358    if (!strcmp(mode, "LOCAL")) imode = 0;
359    if (!strcmp(mode, "PROOF")) imode = 1;
360    if (!strcmp(mode, "GRID"))  imode = 2;
361    switch (imode) {
362       case 0:
363          if (!chain) {
364             ::Error("AnalysisTrainHMPID.C::StartAnalysis", "Cannot create the chain");
365             return;
366          }
367          mgr->StartAnalysis(mode, chain, kNumberOfEvents);
368          return;
369       case 1:
370          if (!kProofDataSet.Length()) {
371             ::Error("AnalysisTrainHMPID.C::StartAnalysis", "kProofDataSet is empty");
372             return;
373          }
374          mgr->StartAnalysis(mode, kProofDataSet, kProofEvents,kProofOffset);
375          return;
376       case 2:
377          if (kPluginUse) {
378             if (!mgr->GetGridHandler()) {
379                ::Error("AnalysisTrainHMPID.C::StartAnalysis", "Grid plugin not initialized");
380                return;
381             }
382             mgr->StartAnalysis("grid");
383          } else {
384             if (!chain) {
385                ::Error("AnalysisTrainHMPID.C::StartAnalysis", "Cannot create the chain");
386                return;
387             }
388             mgr->StartAnalysis(mode, chain);
389          }
390       return;
391    }
392 }
393
394 //______________________________________________________________________________
395 void CheckModuleFlags(const char *mode) {
396 // Checks selected modules and insure compatibility
397    Int_t imode = -1;
398    if (!strcmp(mode, "LOCAL")) imode = 0;
399    if (!strcmp(mode, "PROOF")) imode = 1;
400    if (!strcmp(mode, "GRID"))  imode = 2;
401
402
403    if (kUseCPAR) {
404      kPluginAliRootVersion    = ""; // NO aliroot if we use CPAR
405    }
406
407    if (imode==1) {
408       if (!kUsePAR) {
409          ::Info("AnalysisTrainHMPID.C::CheckModuleFlags", "PAR files enabled due to PROOF analysis");
410          kUsePAR = kTRUE;
411       }   
412    }  
413    if (imode != 2) {
414       ::Info("AnalysisTrainHMPID.C::CheckModuleFlags", "AliEn plugin disabled since not in GRID mode");
415       kPluginUse = kFALSE; 
416    }
417
418    if(!kIsMC){
419       // switch off anything related to MC
420       kUseMC = kFALSE;
421       kUseTR = kFALSE;
422    }
423
424    if (iAODanalysis) {
425    // AOD analysis
426       if (kUseMC)
427          ::Info("AnalysisTrainHMPID.C::CheckModuleFlags", "MC usage disabled in analysis on AOD's");
428       kUseMC = kFALSE;
429       kUseTR = kFALSE;
430       if (iESDfilter)
431          ::Info("AnalysisTrainHMPID.C::CheckModuleFlags", "ESD filter disabled in analysis on AOD's");
432       iESDfilter   = 0;
433       if (iPhysicsSelection)
434          ::Info("AnalysisTrainHMPID.C::CheckModuleFlags", "Physics Selection disabled in analysis on AOD's");
435       iPhysicsSelection   = 0;
436       if (!iAODhandler) {
437          if (iJETAN) 
438             ::Info("AnalysisTrainHMPID.C::CheckModuleFlags", "JETAN disabled in analysis on AOD's without AOD handler");
439          iJETAN = 0;
440       }
441       if(iHMPID)::Info("AnalysisTrainHMPID.C::CheckModuleFlags", "HMPID analysis disabled in analysis on AOD's");
442       iHMPID = 0;
443       if(iHMPIDperf)::Info("AnalysisTrainHMPID.C::CheckModuleFlags", "HMPID performance disabled in analysis on AOD's");
444       iHMPIDperf = 0;
445    } else {   
446    // ESD analysis
447       if (!kUseMC){
448          kUseTR = kFALSE;
449          if(kUseKinefilter)::Info("AnalysisTrainHMPID.C::CheckModuleFlags", "Kine Filter disabled in analysis without MC");
450          kUseKinefilter = kFALSE;
451       }
452       if (iJETAN){
453          iESDfilter=1;
454       }
455       if (!iESDfilter){
456          kUseKinefilter = kFALSE;
457          kUseMuonfilter = kFALSE;
458       }
459    }
460
461    iJETANLib = iJETAN && 1;
462    if (iESDfilter) {iAODhandler=1;}
463    if (kUseKinefilter && !kUseMC) kUseKinefilter = kFALSE;
464    
465 }
466
467
468 //______________________________________________________________________________
469 Bool_t Connect(const char *mode) {
470 // Connect <username> to the back-end system.
471    Int_t imode = -1;
472    if (!strcmp(mode, "LOCAL")) imode = 0;
473    if (!strcmp(mode, "PROOF")) imode = 1;
474    if (!strcmp(mode, "GRID"))  imode = 2;
475    TString username = gSystem->Getenv("alien_API_USER");
476    switch (imode) {
477      case 0:
478        break;
479      case 1:
480        if  (!username.Length()) {
481          ::Error(Form("AnalysisTrainHMPID.C::Connect <%s>", mode), "Make sure you:\n \
482                         1. Have called: alien-token-init <username>\n \
483                         2. Have called: >source /tmp/gclient_env_$UID");
484          return kFALSE;
485        }
486        ::Info("AnalysisTrainHMPID.C::Connect", "Connecting user <%s> to PROOF cluster <%s>", 
487                 username.Data(), kProofCluster.Data());
488        gEnv->SetValue("XSec.GSI.DelegProxy", "2");
489        TProof::Open(Form("%s@%s", username.Data(), kProofCluster.Data()));       
490        if (!gProof) {
491          if (strcmp(gSystem->Getenv("XrdSecGSISRVNAMES"), "lxfsrd0506.cern.ch"))
492            ::Error(Form("AnalysisTrainHMPID.C::Connect <%s>", mode), "Environment XrdSecGSISRVNAMES different from lxfsrd0506.cern.ch");
493            return kFALSE;
494          }
495        if(kProofClearPackages)gProof->ClearPackages();
496        break;
497      case 2:      
498        if  (!username.Length()) {
499          ::Error(Form("AnalysisTrainHMPID.C::Connect <%s>", mode), "Make sure you:\n \
500                         1. Have called: alien-token-init <username>\n \
501                         2. Have called: >source /tmp/gclient_env_$UID");
502          return kFALSE;
503        }
504        if (kPluginUse && !gSystem->Getenv("alien_CLOSE_SE")) {
505          ::Error(Form("AnalysisTrainHMPID.C::Connect <%s>", mode), 
506                         "When using the AliEn plugin it is preferable to define the \
507                         variable alien_CLOSE_SE in your environment.");
508          return kFALSE;
509        }
510        ::Info("AnalysisTrainHMPID.C::Connect", "Connecting user <%s> to AliEn ...", 
511                 username.Data());
512        TGrid::Connect("alien://");
513        if (!gGrid || !gGrid->IsConnected()) return kFALSE;
514        break;
515      default:
516        ::Error("AnalysisTrainHMPID.C::Connect", "Unknown run mode: %s", mode);
517        return kFALSE;
518    }
519    ::Info("AnalysisTrainHMPID.C::Connect","Connected in %s mode", mode);
520    return kTRUE;
521 }
522
523
524 //______________________________________________________________________________
525 Bool_t LoadCommonLibraries(const char *mode)
526 {
527 // Load common analysis libraries.
528    Int_t imode = -1;
529    if (!strcmp(mode, "LOCAL")) imode = 0;
530    if (!strcmp(mode, "PROOF")) imode = 1;
531    if (!strcmp(mode, "GRID"))  imode = 2;
532    if (!gSystem->Getenv("ALICE_ROOT")) {
533       ::Error("AnalysisTrainHMPID.C::LoadCommonLibraries", "Analysis train requires that analysis libraries are compiled with a local AliRoot"); 
534       return kFALSE;
535    }   
536    Bool_t success = kTRUE;
537    // ROOT libraries
538    gSystem->Load("libTree");
539    gSystem->Load("libGeom");
540    gSystem->Load("libVMC");
541    gSystem->Load("libPhysics");
542    
543    // Load framework classes. Par option ignored here.
544    switch (imode) {
545       case 0:
546       case 2:
547          if (kUseCPAR) {
548             success &= LoadLibrary("STEERBase", mode, kTRUE);
549             success &= LoadLibrary("ESD", mode, kTRUE);
550             success &= LoadLibrary("AOD", mode, kTRUE);
551             success &= LoadLibrary("ANALYSIS", mode, kTRUE);
552             success &= LoadLibrary("ANALYSISalice", mode, kTRUE);
553             success &= LoadLibrary("CORRFW", mode, kTRUE);
554          } else {   
555             success &= LoadLibrary("libSTEERBase.so",     mode, kTRUE);
556             success &= LoadLibrary("libESD.so",           mode, kTRUE);
557             success &= LoadLibrary("libAOD.so",           mode, kTRUE);
558             success &= LoadLibrary("libANALYSIS.so",      mode, kTRUE);
559             success &= LoadLibrary("libANALYSISalice.so", mode, kTRUE);
560             success &= LoadLibrary("libCORRFW.so",        mode, kTRUE);
561             gROOT->ProcessLine(".include $ALICE_ROOT/include");
562          }
563          break;
564       case 1:
565          if (!kProofUseAFPAR) {
566             success &= LoadLibrary("STEERBase", mode);
567             success &= LoadLibrary("ESD", mode);
568             success &= LoadLibrary("AOD", mode);
569             success &= LoadLibrary("ANALYSIS", mode);
570             success &= LoadLibrary("ANALYSISalice", mode);
571             success &= LoadLibrary("CORRFW", mode);
572          } else {
573             success &= !gProof->EnablePackage(kProofAFversion);
574             success &= LoadLibrary("CORRFW", mode);
575          }
576          break;
577       default:
578          ::Error("AnalysisTrainHMPID.C::LoadCommonLibraries", "Unknown run mode: %s", mode);
579          return kFALSE;
580    }
581    if (success) {
582       ::Info("AnalysisTrainHMPID.C::LoadCommodLibraries", "Load common libraries:    SUCCESS");
583       ::Info("AnalysisTrainHMPID.C::LoadCommodLibraries", "Include path for Aclic compilation:\n%s",
584               gSystem->GetIncludePath());
585    } else {
586       ::Info("AnalysisTrainHMPID.C::LoadCommodLibraries", "Load common libraries:    FAILED");
587    }
588
589    return success;
590 }
591
592
593 //______________________________________________________________________________
594 Bool_t LoadAnalysisLibraries(const char *mode)
595 {
596 // Load common analysis libraries.
597    Bool_t success = kTRUE;
598    if (iESDfilter) {
599       if (!LoadLibrary("PWGHFbase", mode, kTRUE) ||
600           !LoadLibrary("PWGmuon", mode, kTRUE)) return kFALSE;
601    }   
602
603    if (iJETANLib) {
604      // this part needs some rework in case we do not need the fastjed finders for processing
605      if (!LoadLibrary("JETAN", mode, kTRUE)) return kFALSE;
606      if (!strcmp(mode, "PROOF")){
607        gProof->Exec("gSystem->Load\(\"/afs/cern.ch/user/d/dperrino/public/libCGAL.so\"\)", kTRUE); 
608        gProof->Exec("gSystem->Load\(\"/afs/cern.ch/user/d/dperrino/public/libfastjet.so\"\)", kTRUE); 
609        // problem when loading siscone copiled with different gcc version??
610        // gProof->Exec("gSystem->Load\(\"/afs/cern.ch/user/d/dperrino/public/libsiscone.so\"\)", kTRUE); 
611        gProof->Exec("gSystem->Load\(\"/afs/cern.ch/user/d/dperrino/public/libSISConePlugin.so\"\)", kTRUE);      
612      }
613      if(!kUsePAR){ 
614        if (!LoadLibrary("CGAL", mode, kTRUE)) return kFALSE;
615        if (!LoadLibrary("fastjet", mode, kTRUE)) return kFALSE;
616        if (!LoadLibrary("siscone", mode, kTRUE)) return kFALSE;
617        if (!LoadLibrary("SISConePlugin", mode, kTRUE)) return kFALSE;
618      }
619      else{
620        if (!LoadLibrary("libCGAL.so", mode, kTRUE)) return kFALSE;
621        if (!LoadLibrary("libfastjet.so", mode, kTRUE)) return kFALSE;
622        if (!LoadLibrary("libsiscone.so", mode, kTRUE)) return kFALSE;
623        if (!LoadLibrary("libSISConePlugin.so", mode, kTRUE)) return kFALSE;
624      }
625      if (!LoadLibrary("FASTJETAN", mode, kTRUE)) return kFALSE;
626    }
627
628    if(iHMPID){
629      if (!LoadSource(Form("%s/HMPID/AliHMPIDAnalysisTask.cxx",gSystem->ExpandPathName("$ALICE_ROOT")), mode, kTRUE))return kFALSE;
630    }
631    
632    if(iHMPIDperf){
633      if (!LoadSource(Form("%s/HMPID/AliHMPIDPerformanceTask.cxx",gSystem->ExpandPathName("$ALICE_ROOT")), mode, kTRUE))return kFALSE;
634    }   
635
636    if(iHMPIDJets){
637      if (!LoadSource(Form("%s/HMPID/AliAnalysisTaskJetsHMPID.cxx",gSystem->ExpandPathName("$ALICE_ROOT")), mode, kTRUE))return kFALSE;
638    }
639    
640    if (iJETANLib) {
641      if (!LoadLibrary("JETAN", mode, kTRUE)) return kFALSE;
642    }
643
644    ::Info("AnalysisTrainHMPID.C::LoadAnalysisLibraries", "Load other libraries:   SUCCESS");
645    return kTRUE;
646 }
647
648
649 //______________________________________________________________________________
650 Bool_t LoadLibrary(const char *module, const char *mode, Bool_t rec=kFALSE)
651 {
652 // Load a module library in a given mode. Reports success.
653    Int_t imode = -1;
654    Int_t result;
655    TString smodule(module);
656    if (!strcmp(mode, "LOCAL")) imode = 0;
657    if (!strcmp(mode, "PROOF")) imode = 1;
658    if (!strcmp(mode, "GRID"))  imode = 2;
659    TString mod(module);
660    if (!mod.Length()) {
661       ::Error("AnalysisTrainHMPID.C::LoadLibrary", "Empty module name");
662       return kFALSE;
663    }   
664    // If a library is specified, just load it
665    if (smodule.EndsWith(".so")) {
666       mod.Remove(mod.Index(".so"));
667       result = gSystem->Load(mod);
668       if (result < 0) {
669          ::Error("AnalysisTrainHMPID.C::LoadLibrary", "Could not load library %s", module);
670          return kFALSE;
671       }
672       if (rec) anaLibs += Form("%s.so ",mod.Data()); 
673       if (rec) anaLibsExtra += Form("%s.so ",mod.Data()); 
674       return kTRUE;
675    } 
676    // Check if the library is already loaded
677    if (strlen(gSystem->GetLibraries(module, "", kFALSE)) > 0)
678       return kTRUE;    
679    switch (imode) {
680       case 0:
681       case 2:
682          if (kUsePAR) {
683             result = SetupPar(module);
684             if (rec) anaPars += Form("%s.par ", module);
685          } else {
686             result = gSystem->Load(Form("lib%s", module));
687             if (rec) anaLibs += Form("lib%s.so ", module);
688          }   
689          break;
690       case 1:
691              if(!gSystem->AccessPathName(module)){
692                ::Info("AnalysisTrainHMPID.C::LoadLibrary", "Removing directory %s",module);
693                gSystem->Exec(Form("rm -rf %s",module));
694          }
695          result = gProof->UploadPackage(module);
696          if (result<0) {
697             result = gProof->UploadPackage(gSystem->ExpandPathName(Form("$ALICE_ROOT/%s.par", module)));
698             if (result<0) {
699                ::Error("AnalysisTrainHMPID.C::LoadLibrary", "Could not find module %s.par in current directory nor in $ALICE_ROOT", module);
700                return kFALSE;
701             }
702          }   
703          result = gProof->EnablePackage(module);
704          break;
705       default:
706          return kFALSE;
707    }         
708    if (result < 0) {
709       ::Error("AnalysisTrainHMPID.C::LoadLibrary", "Could not load module %s", module);
710       return kFALSE;
711    }
712    return kTRUE;
713 }           
714
715 //______________________________________________________________________________
716 Bool_t LoadSource(const char *source, const char *mode, Bool_t rec=kFALSE)
717 {
718 // Load a module library in a given mode. Reports success.
719    Int_t imode = -1;
720    Int_t result = -1;
721    if (!strcmp(mode, "LOCAL")) imode = 0;
722    if (!strcmp(mode, "PROOF")) imode = 1;
723    if (!strcmp(mode, "GRID"))  imode = 2;
724    TString ssource(source);
725    TString basename = gSystem->BaseName(ssource.Data());
726    if (!ssource.Length()) {
727       ::Error("AnalysisTrainHMPID.C::LoadSource", "Empty task name");
728       return kFALSE;
729    }
730    // we have a source code so compile it
731    if (ssource.EndsWith(".cxx")) {
732      // need to copy it here other wise the path is also used on grid...
733      ssource.Remove(ssource.Index(".cxx"));
734      basename.Remove(basename.Index(".cxx"));
735      Printf("LoadSources:: Copying...  path %s{cxx,h}",ssource.Data());
736      gSystem->Exec(Form("cp %s.cxx . ",ssource.Data()));
737      gSystem->Exec(Form("cp %s.h . ",ssource.Data()));
738      // Path to code
739      // only needed for local compilation, in grid and proof mode 
740      // the task headers are uploaded 
741      //     path.Remove(path.Index(gSystem->BaseName(path.Data())));
742      // Printf("LoadSources:: Including path %s",path.Data());
743      //  if(path.Length()>0)gROOT->ProcessLine(Form(".include %s",path.Data()));
744      Printf("LoadSources:: Loading...  path %s",basename.Data());
745      switch (imode) {
746      case 0:
747        result = gROOT->LoadMacro(Form("%s.cxx++g",basename.Data()));
748        break;
749      case 1:
750        result = gProof->Load(Form("%s.cxx++g",basename.Data()));
751        break;
752      case 2:
753        result = gROOT->LoadMacro(Form("%s.cxx++g",basename.Data()));
754        if (rec){
755        // what we want to compile
756          anaSources += Form("%s.cxx ",basename.Data());
757        // what we need as input...
758          anaLibs += Form("%s.cxx %s.h ",basename.Data(),basename.Data());
759        }
760        break;
761      default:
762        return kFALSE;
763      }
764    }
765    if (result < 0) {
766       ::Error("AnalysisTrainHMPID.C::LoadSources", "Could not load source %s", source);
767       return kFALSE;
768    }
769    return kTRUE;
770 }
771
772 //______________________________________________________________________________
773 TChain *CreateChain(const char *mode, const char *plugin_mode)
774 {
775 // Create the input chain
776    Int_t imode = -1;
777    if (!strcmp(mode, "LOCAL")) imode = 0;
778    if (!strcmp(mode, "PROOF")) imode = 1;
779    if (!strcmp(mode, "GRID"))  imode = 2;
780    TChain *chain = NULL;
781    // Local chain
782    switch (imode) {
783       case 0:
784          if (iAODanalysis) {
785             if (!kLocalXMLDataset.Length()) {
786                // Local AOD
787                chain = new TChain("aodTree");
788                TString line;
789                ifstream in;
790                in.open(kLocalDataList.Data());
791                    while (in.good()) {
792                   in >> line;
793                   if (line.Length() == 0) continue;
794                // cout << " line = " << line << endl;
795                chain->Add(line.Data());
796                    }
797             } else {
798                // Interactive AOD
799                chain = CreateChainSingle(kLocalXMLDataset, "aodTree");
800             }
801          } else {
802             if (!kLocalXMLDataset.Length()) {
803                // Local ESD
804                chain = new TChain("esdTree");
805                TString line;
806                ifstream in;
807                in.open(kLocalDataList.Data());
808                while (in.good()) {
809                   in >> line;
810                   if (line.Length() == 0) continue;
811                   cout << " line = " << line << endl;
812                   chain->Add(line.Data());
813                }
814             } else {
815               // Interactive ESD
816               chain = CreateChainSingle(kLocalXMLDataset, "esdTree");
817                 }
818          }
819          break;
820       case 1:
821          break;
822       case 2:
823          if (kPluginUse) {
824             AliAnalysisGrid *alienHandler = CreateAlienHandler(plugin_mode);
825             AliAnalysisManager::GetAnalysisManager()->SetGridHandler(alienHandler);
826          } else {
827             TString           treeName = "esdTree";
828             if (iAODanalysis) treeName = "aodTree";
829             chain = CreateChainSingle("wn.xml", treeName);
830          }
831          break;      
832       default:   
833    }
834    if (chain && chain->GetNtrees()) return chain;
835    return NULL;
836 }   
837
838 //______________________________________________________________________________
839 TChain* CreateChainSingle(const char* xmlfile, const char *treeName)
840 {
841    printf("*******************************\n");
842    printf("*** Getting the ESD Chain   ***\n");
843    printf("*******************************\n");
844    TAlienCollection * myCollection  = TAlienCollection::Open(xmlfile);
845
846    if (!myCollection) {
847       ::Error("AnalysisTrainHMPID.C::CreateChainSingle", "Cannot create an AliEn collection from %s", xmlfile) ;
848       return NULL ;
849    }
850
851    TChain* chain = new TChain(treeName);
852    myCollection->Reset() ;
853    while ( myCollection->Next() ) chain->Add(myCollection->GetTURL("")) ;
854    chain->ls();
855    return chain;
856 }
857
858 //______________________________________________________________________________
859 Int_t SetupPar(char* pararchivename)
860 {
861    if (!pararchivename || !strlen(pararchivename)) return -1;
862    char processline[1024];
863    if (gSystem->AccessPathName(Form("%s.par", pararchivename))) {
864       if (!gSystem->AccessPathName(Form("%s/%s.par", gSystem->Getenv("ALICE_ROOT"),pararchivename))) {
865          ::Info("AnalysisTrainHMPID.C::SetupPar", "Getting %s.par from $ALICE_ROOT", pararchivename);
866          TFile::Cp(gSystem->ExpandPathName(Form("$ALICE_ROOT/%s.par", pararchivename)), 
867                    Form("%s.par",pararchivename));
868       } else {
869          ::Error("AnalysisTrainHMPID.C::SetupPar", "Cannot find %s.par", pararchivename);
870          return -1;
871       }   
872    }
873    gSystem->Exec(Form("tar xvzf %s.par", pararchivename));
874
875    TString ocwd = gSystem->WorkingDirectory();
876    if (!gSystem->ChangeDirectory(pararchivename)) return -1;
877         
878    // check for BUILD.sh and execute
879    if (!gSystem->AccessPathName("PROOF-INF/BUILD.sh")) {
880       printf("*******************************\n");
881       printf("*** Building PAR archive    ***\n");
882       printf("*******************************\n");          
883       if (gSystem->Exec("PROOF-INF/BUILD.sh")) {
884          Error("runProcess","Cannot Build the PAR Archive! - Abort!");
885          return -1;
886       }
887    }
888
889         // check for SETUP.C and execute
890         if (!gSystem->AccessPathName("PROOF-INF/SETUP.C")) {
891             printf("*******************************\n");
892             printf("*** Setup PAR archive       ***\n");
893             printf("*******************************\n");
894             gROOT->Macro("PROOF-INF/SETUP.C");
895         }       
896         if (!gSystem->ChangeDirectory(ocwd.Data())) return -1;
897    return 0;
898 }
899
900 //______________________________________________________________________________
901 AliAnalysisAlien* CreateAlienHandler(const char *plugin_mode)
902 {
903 // Check if user has a valid token, otherwise make one. This has limitations.
904 // One can always follow the standard procedure of calling alien-token-init then
905 //   source /tmp/gclient_env_$UID in the current shell.
906    if (!AliAnalysisGrid::CreateToken()) return NULL;
907    AliAnalysisAlien *plugin = new AliAnalysisAlien();
908 // Set the run mode (can be "full", "test", "offline", "submit" or "terminate")
909    plugin->SetRunMode(plugin_mode);
910    if (kPluginUseProductionMode) plugin->SetProductionMode();
911    plugin->SetJobTag(kJobTag);
912    plugin->SetNtestFiles(1);
913 //   plugin->SetPreferedSE("ALICE::NIHAM::File");
914 // Set versions of used packages
915    plugin->SetAPIVersion("V1.1x");
916    plugin->SetROOTVersion(kPluginRootVersion);
917    plugin->SetAliROOTVersion(kPluginAliRootVersion);
918
919 // Declare input data to be processed.
920 // Method 1: Create automatically XML collections using alien 'find' command.
921 // Define production directory LFN
922    plugin->SetGridDataDir(kGridDatadir.Data());
923 // Set data search pattern
924    if (iAODanalysis) plugin->SetDataPattern(" *AliAOD.root");
925    else plugin->SetDataPattern(Form(" %s/*/*ESDs.root",kGridPassPattern.Data()));
926 // ...then add run numbers to be considered
927    plugin->SetRunPrefix("000"); // if real data
928    plugin->SetRunRange(kGridRunRange[0], kGridRunRange[1]);
929
930    if(kGridLocalRunList.Length()>0){
931      ifstream in1;
932      in1.open(kGridLocalRunList.Data());
933      int iRun;
934      // just use run numbers, negatives will be excluded
935      while(in1>>iRun){
936        if(iRun>0){
937        Printf("AnalysisTrainHMPID Adding run number from File %s", Form(kGridRunPattern.Data(),iRun));
938        plugin->AddRunNumber(Form(kGridRunPattern.Data(),iRun));
939        } else{
940          Printf("AnalysisTrainHMPID Skipping run number from File %d", iRun);
941        }
942      }
943    }
944
945 // Method 2: Declare existing data files (raw collections, xml collections, root file)
946 // If no path mentioned data is supposed to be in the work directory (see SetGridWorkingDir())
947 // XML collections added via this method can be combined with the first method if
948 // the content is compatible (using or not tags)
949 //   plugin->AddDataFile("Hijing.xml");
950 //   plugin->AddDataFile("/alice/data/2008/LHC08c/000057657/raw/Run57657.Merged.RAW.tag.root");
951 // Define alien work directory where all files will be copied. Relative to alien $HOME.
952    TString alien_workdir = "";
953
954    alien_workdir += kGridWorkDir.Data();
955    if(kGridDataSet.Length()>0)alien_workdir += Form("/%s",kGridDataSet.Data());
956    plugin->SetGridWorkingDir(alien_workdir.Data());
957
958    // Declare alien output directory. Relative to working directory.
959    if (!kGridOutdir.Length()) kGridOutdir = Form("output_%s",kTrainName.Data());
960    plugin->SetGridOutputDir(kGridOutdir);
961
962    // Add external packages
963    if (iJETAN) {
964       plugin->AddExternalPackage("boost::v1_43_0");
965       plugin->AddExternalPackage("cgal::v3.6");
966       plugin->AddExternalPackage("fastjet::v2.4.2");
967    }   
968
969    // set extra libs before par file compilation
970    anaLibs += kGridExtraFiles;
971    anaLibs  = anaLibs.Strip();   
972    Printf("anaLibs %s",anaLibs.Data());
973    Printf("anaLibsExtra %s",anaLibsExtra.Data());
974
975    if (anaLibs.Length())          plugin->SetAdditionalLibs(anaLibs.Data());
976    if (anaLibsExtra.Length())     plugin->SetAdditionalRootLibs(anaLibsExtra.Data());
977
978    TString ana_sources = "";
979    TString ana_add = "";
980    if (kUsePAR && anaPars.Length()) {
981       printf("%s\n", anaPars.Data());
982       TObjArray *arr;
983       TObjString *objstr;
984       arr = anaPars.Tokenize(" ");
985       TIter next(arr);
986       while ((objstr=(TObjString*)next())) plugin->EnablePackage(objstr->GetString());
987       delete arr;
988    } 
989    
990 // Declare the analysis source files names separated by blancs. To be compiled runtime
991 // using ACLiC on the worker nodes.
992    ana_sources = anaSources.Strip();
993 // Declare all libraries (other than the default ones for the framework. These will be
994 // loaded by the generated analysis macro. Add all extra files (task .cxx/.h) here.
995
996    if (ana_sources.Length()) plugin->SetAnalysisSource(ana_sources);
997    plugin->SetExecutableCommand(kPluginExecutableCommand.Data());
998    // Declare the output file names separated by blancs.
999    // (can be like: file.root or file.root@ALICE::Niham::File)
1000    plugin->SetUseSubmitPolicy(kFALSE);
1001    plugin->SetMergeExcludes(kGridMergeExclude);
1002    plugin->SetMaxMergeFiles(kGridMaxMergeFiles);
1003    plugin->SetMaxMergeStages(kGridMaxMergeStages);
1004    plugin->SetNrunsPerMaster(kGridRunsPerMaster);
1005    plugin->SetMergeViaJDL(kPluginMergeViaJDL);
1006    // Use fastread option
1007    plugin->SetFastReadOption(kPluginFastReadOption);
1008    // UseOverwrite mode
1009    plugin->SetOverwriteMode(kPluginOverwriteMode);
1010    // Optionally define the files to be archived.
1011    //   plugin->SetOutputArchive("log_archive.zip:stdout,stderr@ALICE::NIHAM::File root_archive.zip:AliAOD.root,AOD.tag.root@ALICE::NIHAM::File");
1012    plugin->SetOutputToRunNo(kPluginOutputToRunNumber);     // write the output to subdirs named after run number
1013 //   plugin->SetDefaultOutputs(kFALSE);
1014
1015    // Put default output files to archive
1016    TString listhists = "";
1017    TString listaods  = "";
1018    AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
1019    TIter next(mgr->GetOutputs());
1020    AliAnalysisDataContainer *output;
1021    while ((output=(AliAnalysisDataContainer*)next())) {
1022       const char *filename = output->GetFileName();
1023       if (!(strcmp(filename, "default"))) {
1024          if (!mgr->GetOutputEventHandler()) continue;
1025          filename = mgr->GetOutputEventHandler()->GetOutputFileName();
1026          if (listaods.Length()) listaods += " ";
1027          listaods += filename;
1028       } else {
1029          if(!listhists.Contains(filename)){
1030             if (listhists.Length()) listhists += " ";
1031             listhists += filename;
1032          }
1033       }
1034    }
1035
1036    if (mgr->GetExtraFiles().Length()) {
1037      if (listaods.Length()) listaods += " ";
1038      listaods += mgr->GetExtraFiles();
1039    }
1040
1041    TString outputArchive;
1042    outputArchive = Form("log_archive.zip:std*r@%s",kGridOutputStorages.Data());
1043    listaods.ReplaceAll(" ", ",");
1044    listhists.ReplaceAll(" ", ",");
1045    if (listhists.Length()) listhists = Form("hist_archive.zip:%s@%s", listhists.Data(), kGridOutputStorages.Data());
1046    if (listaods.Length())  listaods  = Form("aod_archive.zip:%s@%s", listaods.Data(), kGridOutputStorages.Data());
1047
1048    if (!listhists.Length() && !listaods.Length()) {
1049       ::Fatal("AnalysisTrainHMPID", "No task output !");
1050    }
1051
1052    if (listaods.Length()) {
1053       outputArchive += " ";
1054       outputArchive += listaods;
1055    }
1056    if (listhists.Length()) {
1057       outputArchive += " ";
1058       outputArchive += listhists;
1059    }
1060 //   plugin->SetOutputArchive(outputArchive);
1061
1062 // Optionally set a name for the generated analysis macro (default MyAnalysis.C)
1063    plugin->SetAnalysisMacro(Form("%s.C", kTrainName.Data()));
1064 // Optionally set maximum number of input files/subjob (default 100, put 0 to ignore)
1065    plugin->SetSplitMaxInputFileNumber(kGridFilesPerJob);
1066 // Optionally set number of failed jobs that will trigger killing waiting sub-jobs.
1067 //   plugin->SetMaxInitFailed(5);
1068 // Optionally resubmit threshold.
1069 //   plugin->SetMasterResubmitThreshold(90);
1070 // Optionally set time to live (default 30000 sec)
1071    plugin->SetTTL(30000);
1072 // Optionally set input format (default xml-single)
1073    plugin->SetInputFormat("xml-single");
1074 // Optionally modify the name of the generated JDL (default analysis.jdl)
1075    plugin->SetJDLName(Form("%s.jdl", kTrainName.Data()));
1076 // Optionally modify the executable name (default analysis.sh)
1077    plugin->SetExecutable(Form("%s.sh", kTrainName.Data()));
1078 // Optionally modify job price (default 1)
1079    plugin->SetPrice(1);      
1080 // Optionally modify split mode (default 'se')    
1081    plugin->SetSplitMode("se");
1082    plugin->SetCheckCopy(kFALSE);
1083    return plugin;
1084 }
1085
1086 //______________________________________________________________________________
1087 Bool_t LoadConfig(const char *filename)
1088 {
1089 // Read train configuration from file
1090    if (gSystem->AccessPathName(filename)) {
1091       ::Error("AnalysisTrainHMPID.C::LoadConfig", "Config file name not found");
1092       return kFALSE;
1093    }   
1094    gROOT->ProcessLine(Form(".x %s", filename));
1095    ::Info("AnalysisTrainHMPID.C::LoadConfig", "Train configuration loaded from file %s", filename);
1096    return kTRUE;
1097 }
1098
1099 //______________________________________________________________________________
1100 Bool_t PatchJDL(){
1101   Printf(">>> Patching JDL");
1102   AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
1103   AliAnalysisAlien*    gridHandler = (AliAnalysisAlien*)mgr->GetGridHandler();
1104   TGridJDL *jdl = gridHandler->GetGridJDL();
1105   if(iJETAN)jdl->AddToPackages("fastjet","v2.4.0");
1106   gridHandler->WriteJDL(kFALSE);
1107   Printf("<<<  Patching JDL");
1108   return kTRUE;
1109 }
1110
1111 //______________________________________________________________________________
1112 Bool_t PatchAnalysisMacro(){
1113   Printf(">>> Patching AnalysisMacro");
1114   gSystem->Exec(Form("mv %s.C %s.C_tmp",kTrainName.Data(),kTrainName.Data()));
1115
1116   ifstream in1; 
1117   in1.open(Form("%s.C_tmp", kTrainName.Data()));
1118   char cLine[250];
1119   TString st;
1120   while(in1.getline(cLine,250)){
1121     st += cLine;
1122     st += "\n";
1123   }
1124   Int_t index= -1;
1125   index = st.Index("gSystem->Load(\"libPhysics\");");
1126   index += strlen("gSystem->Load(\"libPhysics\");");
1127   /*
1128     TObjArray *arr;
1129     TObjString *objstr;
1130     arr = anaLibs.Tokenize(" ");
1131     TIter next(arr);
1132
1133     add += "\n\n // added by CKB \n";
1134     while ((objstr=(TObjString*)next())){
1135       if(objstr->GetString().Contains("PWG3"))continue;
1136       if(objstr->GetString().EndsWith(".so"))add += Form("gSystem->Load(\"%s\");\n",objstr->GetString().Data());
1137     }
1138     delete arr; 
1139     */
1140     //    add += Form("AliLog::SetGlobalLogLevel(%d);\n",AliLog::GetGlobalLogLevel());
1141   TString add = "";
1142
1143   if(index<0)Printf("%s:%d index out of bounds",(char*)__FILE__,__LINE__);
1144   add += "\n\n // added by CKB \n";
1145   add += "\n gSystem->AddIncludePath(\"./\"); \n";
1146   if(gGrid && kPluginAliRootVersion.Length()==0){
1147     add += "\n // Dirty hack for TRD reference data \n";
1148     add += "\n gSystem->Setenv(\"ALICE_ROOT\",\"";
1149     add += Form("alien://%s/rootfiles/",gGrid->GetHomeDirectory());
1150     add += "\"); \n";
1151   }
1152   add += "// BKC \n\n";
1153   st.Insert(index,add.Data());
1154
1155   if(kUseCPAR && kPluginAliRootVersion.Length()==0){
1156     index = st.Index("gSystem->AddIncludePath(\"-I$"); // uncommen $ALICE_ROOT include for par files
1157     if(index<0)Printf("%s:%d index out of bounds",(char*)__FILE__,__LINE__);
1158     st.Insert(index,"// CKB comment out whehn no aliroot is provided \n //");
1159   }
1160
1161   ofstream out;
1162   out.open(Form("%s.C", kTrainName.Data()));
1163   if (out.bad()) {
1164     return kFALSE;
1165   }
1166   out << st << endl;
1167   Printf("<<< Patching AnalysisMacro");
1168
1169   Printf(">>> Patching Merge Macro");
1170   gSystem->Exec(Form("mv %s_merge.C %s_merge.C_tmp",kTrainName.Data(),kTrainName.Data()));
1171
1172   ifstream in2; 
1173   in2.open(Form("%s_merge.C_tmp", kTrainName.Data()));
1174   TString st2;
1175   while(in2.getline(cLine,250)){
1176     st2 += cLine;
1177     st2 += "\n";
1178   }
1179   index = st2.Index("gSystem->Load(\"libPhysics\");");
1180   index += strlen("gSystem->Load(\"libPhysics\");");
1181   TString add2 = "";
1182   add2 += "\n gSystem->AddIncludePath(\"./\"); \n";
1183   if(gGrid&&kPluginAliRootVersion.Length()==0){
1184     add2 += "\n // Dirty hack for TRD reference data \n";
1185     add2 += "\n gSystem->Setenv(\"ALICE_ROOT\",\"";
1186     add2 += Form("alien://%s/rootfiles/",gGrid->GetHomeDirectory());
1187     add2 += "\"); \n";
1188   }
1189   add2 += "// BKC \n\n";
1190   if(index<0)Printf("%s:%d index out of bounds",(char*)__FILE__,__LINE__);
1191   st2.Insert(index,add.Data());
1192
1193   if(kUseCPAR&&kPluginAliRootVersion.Length()==0){
1194     index = st2.Index("gSystem->AddIncludePath(\"-I$"); // uncommen $ALICE_ROOT include for par files
1195     if(index<0)Printf("%s:%d index out of bounds",(char*)__FILE__,__LINE__);
1196     st2.Insert(index,"// CKB comment out whehn no aliroot is provided \n //");
1197   }
1198
1199   // do not exclude the extra files from merign, this is done explicitly in this train script
1200   index = st2.Index("mergeExcludes +="); // uncommen $ALICE_ROOT include for par files
1201   if(index<0)Printf("%s:%d index out of bounds",(char*)__FILE__,__LINE__);
1202   st2.Insert(index,"// CKB comment out, handled explicitly by the train macro \n //");
1203
1204
1205   ofstream out2;
1206   out2.open(Form("%s_merge.C", kTrainName.Data()));
1207   if (out2.bad()) {
1208     return kFALSE;
1209   }
1210   out2 << st2 << endl;
1211   Printf("<<< Patching Merging Macro");
1212
1213
1214   return kTRUE;
1215
1216 }