Changes to QA TPC, extra task for cosmics, Added utility classes for UE analysis
[u/mrichter/AliRoot.git] / PWG4 / macros / AnalysisTrainPWG4Jets.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 AnalysisTrain.C
5 // Grid full mode as below (other modes: test, offline, submit, terminate)
6 //    root[1] AnalysisTrainPWG-244Jets("grid", "full")
7 // CAF mode (requires root v5-23-02 + aliroot v4-16-Rev08)
8 //    root[2] AnalysisTrainPWG4Jets("proof")
9 // Local mode requires AliESds.root or AliAOD.root in ./data directory
10 //    root[3] AnalysisTrainPWG4Jets("local")
11 // In proof and grid modes, a token is needed and sourcing the produced environment file.
12 //
13 // If 'saveTrain' flag is set, the train will generate a directory name and run
14 // in this directory. A configuration file 'ConfigTrain.C' will be generated. 
15 // One can replay at any time the train via:
16 //    root[1] AnalysisTrainPWG4Jets(ana_mode, plugin_mode, "train_default_<date>/ConfigTrain.C")
17
18 // For Usage with fastjet run in "offline" first and then "submit"
19 // jdl and analysismacro are automatically patched after "offline" mode
20
21 // =============================================================================
22 // ### General Steering variables
23 // =============================================================================
24 //== general setup variables
25 TString     kTrainName         = "testAnalysis"; // *CHANGE ME* (no blancs or special characters)
26 TString     kJobTag            = "PWG4 Jet Tasks analysis train configured"; // *CHANGE ME*
27
28 // Usage of par files ONLY in grid mode and ONLY if the code is not available
29 // in the deployed AliRoot versions. Par file search path: local dir, if not there $ALICE_ROOT.
30 // To refresh par files, remove the ones in the workdir, then do "make <target.par>" in 
31 // AliRoot.
32 Bool_t      kUsePAR             = kFALSE;  // use par files for extra libs
33 Bool_t      kUseCPAR            = kFALSE;  // use par files for common libs
34 Bool_t      kFillAOD = kFALSE;  // switch of AOD filling for on the fly analysis
35
36 //== general input and output variables
37
38 Int_t       iAODanalysis       = 1;      // Analysis on input AOD's
39 Int_t       iAODhandler        = 1;      // Analysis produces an AOD or dAOD's
40 Int_t       iESDfilter         = 0;      // ESD to AOD filter (barrel + muon tracks)
41 Int_t       iPhysicsSelection  = 1;      // ESD to AOD filter (barrel + muon tracks)
42 Bool_t      kUseKinefilter     = kFALSE; // use Kinematics filter
43 Bool_t      kUseMuonfilter     = kFALSE; // use Kinematics filter
44 TString     kCommonOutputFileName = "PWG4_JetTasksOutput.root";
45
46
47 //== general process variables
48
49 // ### Other flags to steer the analysis
50 //==============================================================================
51 Bool_t      kSkipTerminate      = kTRUE; // Do not call Teminate
52 Bool_t      kUseDate            = kFALSE; // use date in train name
53 Bool_t      kUseDebug           = kTRUE; // activate debugging
54 Int_t       kUseSysInfo         = 0; // activate debugging
55 Long_t      kNumberOfEvents     = 1234567890; // number of events to process from the chain
56 Bool_t      kUseMC              = kTRUE;  // use MC info
57 Bool_t      kIsMC               = kTRUE;  // is MC info, if false it overwrites Use(AOD)MC
58 Bool_t      kUseAODMC           = kTRUE;  // use MC infA
59 Bool_t      kUseESDTags         = kFALSE; // use ESD tags for selection
60 Bool_t      kUseTR              = kFALSE;  // use track references
61 Bool_t      kUseAODTags         = kFALSE;  // use AOD tags
62 Bool_t      kSaveTrain          = kFALSE;  // save train configuration as: 
63
64
65 // ### Analysis modules to be included. Some may not be yet fully implemented.
66 //==============================================================================
67 Int_t       iJETAN             = 1;      // Jet analysis (PWG4) // 1 write standard 2 write non-standard jets, 3 wrtie both
68 Int_t       iDIJETAN           = 1;
69 Int_t       iJETANLib          = 1;
70 Int_t       iPWG1QASym         = 0;      // Eva's QA task compiled on the fly...
71 Int_t       iPWG4JetTasks      = 0;      // all jet tasks flag for lib laoding
72 Int_t       iPWG4JetServices   = 0;      // jet spectrum analysis
73 Int_t       iPWG4JetSpectrum   = 0;      // jet spectrum analysis
74 Int_t       iPWG4JCORRAN       = 0;      // JCORRAN module
75 Int_t       iPWG4UE            = 0;      // Underlying Event analysis
76 Int_t       iPWG4TmpSourceSara = 0;      // Underlying Event analysis not in svn
77 Int_t       iPWG4TmpSourceFrag = 0;      // Bastian's Fragmentation function not in svn
78 Int_t       iPWG4JetChem       = 0;      // Jet chemistry 
79 Int_t       iPWG4PtQAMC        = 0;      // Marta's QA tasks 
80 Int_t       iPWG4PtSpectra     = 0;      // Marta's QA tasks 
81 Int_t       iPWG4PtQATPC       = 0;      // Marta's QA tasks 
82 Int_t       iPWG4PtCosmics     = 0;      // Marta's Cosmics Taks 
83 Int_t       iPWG4ThreeJets     = 0;      // Sona's thrust task
84 Int_t       iPWG4KMeans        = 0;      // Andreas' KMeans task 
85 Int_t       iPWG4Cluster       = 0;      // CKB cluster task 
86 Int_t       iPWG4PartCorrLibs  = 0;      // Gustavo's part corr analysis
87 Int_t       iPWG4PartCorr      = 0;      // Gustavo's part corr analysis
88 Int_t       iPWG4CaloQA        = 0;      // Gustavo's part corr analysis
89 Int_t       iPWG4JetCorr       = 0;     // Paul's jet corr analysis
90 Int_t       iPWG4Tagged        = 0;      // Gustavo's part corr analysis
91 Int_t       iPWG4omega3pi      = 0;      // Omega to 3 pi analysis (PWG4) 
92 Int_t       iPWG4GammaConv     = 0;      // Gamma Conversio
93 Int_t       kHighPtFilterMask  = 16;     // change depending on the used AOD Filter
94 TString     kDeltaAODJetName   = "AliAOD.Jets.root";     
95 TString     kDeltaAODPartCorrName   = "deltaAODPartCorr.root";     
96
97
98 //==============================================================================
99 // ### PROOF Steering varibales
100 //==============================================================================
101 //== proof setup variables
102 TString     kProofCluster      = "alicecaf.cern.ch";
103 Bool_t      kProofUseAFPAR     = kFALSE;  // use AF special par file
104 TString     kProofAFversion          = "AF-v4-17";
105 //== proof input and output variables
106 TString     kProofDataSet      = "/COMMON/COMMON/LHC09a4_run8100X#/esdTree";
107 Bool_t      kProofSaveToAlien   = kFALSE; // save proof outputs in AliEn train_[trainName]_ddMonthyyyy_time.C
108 TString     kProofOutdir       = "";
109 Bool_t      kProofClearPackages = kFALSE;
110 Int_t       kProofEvents = 10000;
111 Int_t       kProofOffset = 0;
112 //== proof process variables
113
114
115 //==============================================================================
116 // ### Grid plugin Steering varibiables
117 //==============================================================================
118 //== grid plugin setup variables
119 Bool_t      kPluginUse         = kTRUE;   // do not change
120 Bool_t      kPluginUseProductionMode  = kFALSE;   // use the plugin in production mode
121 TString     kPluginRootVersion       = "v5-26-00b-7";  // *CHANGE ME IF MORE RECENT IN GRID*
122 TString     kPluginAliRootVersion    = "v4-19-15-AN";  // *CHANGE ME IF MORE RECENT IN GRID*                                          
123 Bool_t      kPluginMergeViaJDL       = kTRUE;  // merge via JDL
124 Bool_t      kPluginFastReadOption   = kFALSE;  // use xrootd tweaks
125 Bool_t      kPluginOverwriteMode    = kTRUE;  // overwrite existing collections
126 Int_t       kPluginOutputToRunNumber = 1;     // write the output to subdirs named after run number
127 // TString kPluginExecutableCommand = "root -b -q";
128 TString     kPluginExecutableCommand = "source /Users/kleinb/setup_32bit_aliroot_trunk_clean_root_trunk.sh; alienroot -b -q ";
129
130 // == grid plugin input and output variables
131 TString     kGridDatadir      = "/alice/sim/PDC_08b/LHC09a1/AOD/";
132 TString     kGridLocalRunList = "";
133 TString     kGridOutdir       = ""; // AliEn output directory. If blank will become output_<kTrainName>
134 TString     kGridDataSet      = ""; // sub working directory not to confuse different run xmls 
135 Int_t       kGridRunRange[2]       =  {0, -1}; // Set the run range
136 TString     kGridRunPattern        = "%03d"; // important for leading zeroes!!
137 TString     kGridPassPattern       = "";
138 TString     kGridExtraFiles        = ""; // files that will be added to the input list in the JDL...
139 Int_t       kGridMaxMergeFiles      = 50; // Number of files merged in a chunkgridrunragn
140 TString     kGridMergeExclude       = "AliAOD.root"; // Files that should not be merged
141 TString     kGridOutputStorages      = "disk=2"; // Make replicas on the storages
142 // == grid process variables
143 Int_t       kGridRunsPerMaster     = 100; // Number of runs per master job
144 Int_t       kGridFilesPerJob       = 100; // Maximum number of files per job (gives size of AOD)
145
146 //==============================================================================
147 // ### Local Steering variables
148 //==============================================================================
149 //== local setup variables
150 //== local input and output variables
151 TString     kLocalXMLDataset   = ""; // Change local xml dataset for local interactive analysis
152 TString     kLocalDataList   = "local_deltaaod.txt"; // Change local xml dataset for local interactive analysis
153 // == local process variables
154
155
156
157 // Temporaries.
158 TString anaPars = "";
159 TString anaLibs = "";
160 TString anaLibsExtra = "";
161 TString anaSources = "";
162 // Function signatures
163 class AliAnalysisAlien;
164
165 //______________________________________________________________________________
166 void AnalysisTrainPWG4Jets(const char *analysis_mode="local", 
167                            const char *plugin_mode="",
168                            const char *config_file="",Int_t iOffset = 0)
169 {
170 // Main analysis train macro. If a configuration file is provided, all parameters
171 // are taken from there but may be altered by CheckModuleFlags.
172
173    if (strlen(config_file) && !LoadConfig(config_file)) return;
174
175    if(iOffset)kProofOffset = iOffset;
176    TString smode(analysis_mode);
177    smode.ToUpper();
178    if (kSaveTrain)WriteConfig();
179    // Check compatibility of selected modules
180    CheckModuleFlags(smode);
181    //   gROOT->ProcessLine(".trace");
182
183    printf("==================================================================\n");
184    printf("===========    RUNNING ANALYSIS TRAIN %s IN %s MODE   ==========\n", kTrainName.Data(),smode.Data());
185    printf("==================================================================\n");
186    printf("=  Configuring analysis train for:                               =\n");
187    if (iAODanalysis) printf("=  AOD analysis                                                  =\n");
188    else              printf("=  ESD analysis                                                  =\n");
189    if (iPhysicsSelection)   printf("=  Physics selection                                                    =\n");
190    if (iESDfilter)   printf("=  ESD filter                                                    =\n");
191    if (iJETAN)       printf("=  Jet analysis                                                  =\n");
192    printf("==================================================================\n");
193    printf(":: use Fill AOD      %d\n", (UInt_t)kFillAOD);
194    printf(":: use MC truth      %d\n", (UInt_t)kUseMC);
195    printf(":: use KINE filter   %d\n", (UInt_t)kUseKinefilter);
196    printf(":: use track refs    %d\n", (UInt_t)kUseTR);
197    printf(":: use tags          %d\n", (UInt_t)kUseESDTags);
198    printf(":: use AOD tags      %d\n", (UInt_t)kUseAODTags);
199    printf(":: use debugging     %d\n", (UInt_t)kUseDebug);
200    printf(":: use PAR files     %d\n", (UInt_t)kUsePAR);
201    printf(":: use AliEn plugin  %d\n", (UInt_t)kPluginUse);
202    printf(":: use PWG1 QA sym         %d\n", iPWG1QASym);
203    printf(":: use PWG4 Source Sara    %d\n",iPWG4TmpSourceSara);
204    printf(":: use PWG4 Source BB      %d\n",iPWG4TmpSourceFrag);
205    printf(":: use PWG4 Jet Chem       %d\n",iPWG4JetChem);
206    printf(":: use PWG4 Jet tasks      %d\n",iPWG4JetTasks);
207    printf(":: use PWG4 Jet Services   %d\n",iPWG4JetServices);     
208    printf(":: use PWG4 Jet Spectrum   %d\n",iPWG4JetSpectrum);
209    printf(":: use PWG4 JCORRAN        %d\n",iPWG4JCORRAN);
210    printf(":: use PWG4 UE             %d \n",iPWG4UE); 
211    printf(":: use PWG4 Pt QA MC       %d\n",iPWG4PtQAMC);
212    printf(":: use PWG4 Pt Spectra     %d\n",iPWG4PtSpectra);
213    printf(":: use PWG4 Pt QA TPC      %d\n",iPWG4PtQATPC);     
214    printf(":: use PWG4 Cosmics        %d\n",iPWG4Cosmics);     
215    printf(":: use PWG4 Three Jets     %d\n",iPWG4ThreeJets);
216    printf(":: use PWG4 KMeans         %d\n",iPWG4KMeans);
217    printf(":: use PWG4 Cluster        %d\n",iPWG4Cluster);
218    printf(":: use PWG4 Part Corr      %d\n",iPWG4PartCorr);
219    printf(":: use PWG4 Calo QA        %d\n",iPWG4CaloQA);
220    printf(":: use PWG4 Jet Corr       %d\n",iPWG4JetCorr);
221    printf(":: use PWG4 Tagged         %d\n",iPWG4Tagged);
222    printf(":: use PWG4 omega to 3 pi  %d\n",iPWG4omega3pi);
223    printf(":: use PWG4 Gamma Conv     %d\n",iPWG4GammaConv);
224    printf(":: use HighPt FilterMask   %d\n",kHighPtFilterMask);    
225    
226    //==========================================================================
227    // Connect to back-end system
228    if (!Connect(smode)) {
229       ::Error("AnalysisTrain", "Could not connect to %s back-end", analysis_mode);
230       return;
231    }   
232
233    // Load common libraries and set include path
234    if (!LoadCommonLibraries(smode)) {
235       ::Error("AnalysisTrain", "Could not load common libraries");
236       return;
237    }
238
239
240     
241    // Make the analysis manager and connect event handlers
242    AliAnalysisManager *mgr  = new AliAnalysisManager("PWG4Train", "pwg4 mini train");
243    if (kCommonOutputFileName.Length()>0)mgr->SetCommonFileName(kCommonOutputFileName.Data());
244    if (kProofSaveToAlien) mgr->SetSpecialOutputLocation(kProofOutdir);
245    mgr->SetNSysInfo(0);
246    if (!strcmp(plugin_mode, "test")) mgr->SetNSysInfo(1);
247    if (kUseSysInfo)mgr->SetNSysInfo(kUseSysInfo);
248    mgr->SetSkipTerminate(kSkipTerminate);
249
250    // Load analysis specific libraries
251    if (!LoadAnalysisLibraries(smode)) {
252       ::Error("AnalysisTrain", "Could not load analysis libraries");
253      return;
254    }   
255
256    // Create input handler (input container created automatically)
257    if (iAODanalysis) {
258    // AOD input handler
259       AliAODInputHandler *aodH = new AliAODInputHandler();
260       mgr->SetInputEventHandler(aodH);
261       if (iPWG4JetTasks) aodH->AddFriend(Form("deltas/%s",kDeltaAODJetName.Data()));
262       if (iPWG4PartCorr) aodH->AddFriend(Form("deltas/%s"kDeltaAODJetName.Data()));
263    } else {   
264    // ESD input handler
265       AliESDInputHandler *esdHandler = new AliESDInputHandler();
266       if (kUseESDTags) esdHandler->SetReadTags();
267       esdHandler->SetReadFriends(kFALSE);
268       mgr->SetInputEventHandler(esdHandler);       
269       //      if(iPWG4PtQATPC&& !kTrainName.Contains("pass5"))esdHandler->SetActiveBranches("ESDfriend");
270
271    }
272
273    // Monte Carlo handler
274    if (kUseMC && !iAODanalysis) {
275       AliMCEventHandler* mcHandler = new AliMCEventHandler();
276       mgr->SetMCtruthEventHandler(mcHandler);
277       mcHandler->SetReadTR(kUseTR); 
278    }   
279    // AOD output container, created automatically when setting an AOD handler
280    if (iAODhandler) {
281       // AOD output handler
282       AliAODHandler* aodHandler   = new AliAODHandler();
283       aodHandler->SetOutputFileName("AliAOD.root");
284       aodHandler->SetFillAODforRun(kFillAOD);
285       
286       mgr->SetOutputEventHandler(aodHandler);
287       //
288       if (iAODanalysis) {
289
290         //         aodHandler->SetCreateNonStandardAOD();
291         //      if (iJETAN)aodHandler->SetOutputFileName(kDeltaAODJetName.Data());
292       } 
293       AliAnalysisDataContainer * cout_aod = mgr->GetCommonOutputContainer();
294       cout_aod->SetSpecialOutput();
295    }
296    // Debugging if needed
297
298    if (kUseDebug){
299      mgr->SetDebugLevel(3);
300    }
301    else{
302      AliLog::SetGlobalLogLevel(AliLog::kError);
303    }
304    //==========================================================================
305    // Create the chain. In this example it is created only from ALIEN files but
306    // can be done to work in batch or grid mode as well.
307    TChain *chain = CreateChain(smode, plugin_mode);
308         
309    //==========================================================================
310    // Load the tasks configuration macros for all wagons. These files are supposed now to be
311    // in the current workdir, but in AliEn they will be in the file catalog, 
312    // mapped from AliRoot and pecified in the jdl input list.
313     
314    // For now connection to top input container and common AOD output container
315    // is done in this macro, but in future these containers will be connected
316    // from each task configuration macro.
317    if(iPhysicsSelection && !iAODanalysis){
318      gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
319      AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(kIsMC,kTRUE,kTRUE); // last flag also adds information on  
320    }
321
322    if (iESDfilter && !iAODanalysis) {
323       //  ESD filter task configuration.
324       gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskESDFilter.C");
325       AliAnalysisTaskESDfilter *taskesdfilter = AddTaskESDFilter(kUseKinefilter,kUseMuonfilter);
326    }   
327
328    // AOD tags
329    if (kUseAODTags) {
330       AliAnalysisTaskTagCreator* tagTask = new AliAnalysisTaskTagCreator("AOD Tag Creator");
331       mgr->AddTask(tagTask);
332       AliAnalysisDataContainer *coutTags = mgr->CreateContainer("cTag",  TTree::Class(), 
333                                            AliAnalysisManager::kOutputContainer, "AOD.tag.root");
334       mgr->ConnectInput (tagTask, 0, mgr->GetCommonInputContainer());
335       mgr->ConnectOutput(tagTask, 1, coutTags);
336    }   
337     
338     // Jet analysis
339    if (iJETAN) {
340       gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJets.C");
341       AliAnalysisTaskJets *taskjets = 0;
342       if(iJETAN&1)taskjets = AddTaskJets(kHighPtFilterMask); 
343       if(iJETAN&2){
344         UInt_t selection = 0;
345         if(!kFillAOD) selection = 0xffffff; //&~(1<<13);
346         else selection = 0xffffff&~(1<<13);// selection = 1<<0|1<<1|1<<2|1<<5|1<<6|1<<7|1<<8|1<<9|1<<10|1<<11|1<<12;
347         AddTaskJetsDelta(kDeltaAODJetName.Data(),kHighPtFilterMask,kUseAODMC,selection); 
348       }
349       if (!taskjets) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskJets cannot run for this train conditions - EXCLUDED");
350    }
351
352    if (iDIJETAN) {
353       gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskDiJets.C");
354       AliAnalysisTaskDiJets *taskdijets = 0;
355       if(iDIJETAN&1)taskdijets = AddTaskDiJets(); 
356       if (!taskdijets) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskJets cannot run for this train conditions - EXCLUDED");
357       if(iDIJETAN&2){
358         taskdijets = AddTaskDiJets("jetsAOD_CDF07"); 
359         taskdijets = AddTaskDiJets("jetsAOD_DA07"); 
360         taskdijets = AddTaskDiJets("jetsAOD_FASTJET07"); 
361         taskdijets = AddTaskDiJets("jetsAOD_FASTKT07"); 
362         taskdijets = AddTaskDiJets("jetsAOD_SISCONE07"); 
363         taskdijets = AddTaskDiJets("jetsAOD_UA107");
364       }
365    }
366
367    if(iPWG1QASym){
368      gROOT->LoadMacro("$ALICE_ROOT/PWG1/PilotTrain/AddTaskQAsym.C");
369      AliAnalysisTaskQASym *taskQASym = AddTaskQAsym(-1);
370      if (!taskQASym) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskQASym cannot run for this train conditions - EXCLUDED");
371    }
372
373
374
375    if(iPWG4TmpSourceSara){
376      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskEta.C");
377      AliAnalysisTaskEta *taskEta = AddTaskEta();
378      if (!taskEta) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskEta cannot run for this train conditions - EXCLUDED");
379    }
380
381    if(iPWG4TmpSourceFrag){
382      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskFragFunc.C");
383      UInt_t selection = 1<<2;
384      AliAnalysisTaskFragFunc *taskFrag = AddTaskFragFunc(kHighPtFilterMask, kUseAODMC,iPhysicsSelection, selection);
385      if (!taskFrag) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskFragFunc cannot run for this train conditions - EXCLUDED");
386    }
387
388
389    if(iPWG4JetChem){
390      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJetChem.C");
391      AliAnalysisTask *taskChem = AddTaskJetChem();
392      if (!taskChem) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskJetChem cannot run for this train conditions - EXCLUDED");
393    }
394
395
396    if(iPWG4JetServices){
397      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJetServices.C");
398      AliAnalysisTaskJetServices *taskjetServ = 0;
399      taskjetServ = AddTaskJetServices();
400      if (!taskjetServ) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskJetServices cannot run for this train conditions - EXCLUDED");
401      if(kGridRunRange[0]>0)taskjetServ->SetRunRange(kGridRunRange[0],kGridRunRange[1]);
402      else taskjetServ->SetRunRange(104000,125000);
403      if(!kIsMC) taskjetServ->SetRealData(kTRUE);
404      taskjetServ->SetUsePhysicsSelection((Bool_t)iPhysicsSelection);
405      taskjetServ->SetDebugLevel(0);
406    }
407
408    if(iPWG4JetSpectrum){
409      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJetSpectrum2.C");
410      AliAnalysisTaskJetSpectrum2 *taskjetSpectrum = 0;
411      if(iPWG4JetSpectrum&1){
412        taskjetSpectrum = AddTaskJetSpectrum2("jets","",kHighPtFilterMask,iPhysicsSelection);      
413        if(!iAODanalysis){
414          //      taskjetSpectrum = AddTaskJetSpectrum2("jets","tracks32",32,iPhysicsSelection);       // tmp hack to give it a different name
415          //      taskjetSpectrum = AddTaskJetSpectrum2("jets","tracks64",64,iPhysicsSelection);      
416        }
417        if (!taskjetSpectrum) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskJetSpectrum2 cannot run for this train conditions - EXCLUDED");
418        taskjetSpectrum->SetDebugLevel(1);
419      }
420
421      if(iPWG4JetSpectrum&2){
422        UInt_t selection = 0;
423        if(!iAODanalysis) selection = 0xffffff;
424        else selection = 1<<0|1<<1|1<<2|1<<3|1<<4|1<<5|1<<7|1<<8|1<<9;
425        AddTaskJetSpectrum2Delta(kHighPtFilterMask,kUseAODMC,iPhysicsSelection,selection);
426      }
427    }
428    if(iPWG4JCORRAN){
429      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJCORRANTask.C");
430      AliJCORRANTask* corran = AddTaskJCORRAN(kTRUE);
431      if(!corran)::Warning("AnalysisTrainPWG4Jets", "AliJCORRANTask cannot run for this train conditions - EXCLUDED");
432    }
433
434    if(iPWG4UE){
435      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskUE.C");
436      AliAnalysisTaskUE *taskUE = 0;
437      if(iPWG4UE&1)taskUE = AddTaskUE(); 
438      if(iPWG4UE&2){
439        taskUE  =AddTaskUE("jetsAOD_CDF04","CDF", "LJ", "TRANSV","MSP"); //finder not yet in train
440        taskUE  =AddTaskUE("jetsAOD_CDF07","CDF", "LJ", "TRANSV","MSP");
441        taskUE  =AddTaskUE("jetsAOD_SISCONE04","CDF", "LJ", "TRANSV","MSP");
442        taskUE  =AddTaskUE("jetsAOD_SISCONE07","CDF", "LJ", "TRANSV","MSP"); //finder not yet in train
443        taskUE  =AddTaskUE("jetsAOD_ICDF","CDF","LJ","TRANSV","MSP");
444        taskUE  =AddTaskUE("jetsAOD_FASTKT04","CDF", "LJ", "TRANSV","MSP");
445        taskUE  =AddTaskUE("jetsAOD_FASTKT07","CDF", "LJ", "TRANSV","MSP"); //finder not yet in train
446        taskUE  =AddTaskUE("jetsAOD_NONE","CDF", "MP_eta05", "TRANSV","MSP");
447        taskUE  =AddTaskUE("jetsAOD_NONE","CDF", "MP_eta09", "TRANSV","MSP");
448      }
449
450      if (!taskUE) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskUE cannot run for this train conditions - EXCLUDED");
451    }
452
453    if(iPWG4ThreeJets){
454      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskThreeJets.C");
455      AliAnalysisTaskThreeJets *taskThree = AddTaskThreeJets();
456      if(!taskThree)::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskThreets cannot run for this train conditions - EXCLUDED");
457    }
458    if(iPWG4PtQAMC){
459      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskPWG4HighPtQAMC.C");
460      AliPWG4HighPtQAMC *taskQAMC = AddTaskPWG4HighPtQAMC();
461      if (!taskQAMC) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskQAMC cannot run for this train conditions - EXCLUDED");
462    }
463
464    if(iPWG4PtQATPC){
465      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskPWG4HighPtQATPConly.C");
466      AliPWG4HighPtQATPConly *taskQATPC = 0;
467      if(iPWG4PtQATPC&1)taskQATPC = AddTaskPWG4HighPtQATPConly(1);
468      if(iPWG4PtQATPC&2)taskQATPC = AddTaskPWG4HighPtQATPConly(2);
469
470  if (!taskQATPC) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskQATPC cannot run for this train conditions - EXCLUDED");
471    }
472
473    if(iPWG4Cosmics){
474      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskPWG4CosmicCandidates.C");
475
476      AliPWG4CosmicCandidates *taskPWG4CosmicCandidates = AddTaskPWG4CosmicCandidates(0);
477      taskPWG4CosmicCandidates = AddTaskPWG4CosmicCandidates(1);
478
479      if (!taskPWG4CosmicCandidates) ::Warning("AnalysisTrainPWG4Jets", "AddTaskPWG4CosmicCandidates cannot run for this train conditions - EXCLUDED");
480    }
481
482
483    if(iPWG4PtSpectra){
484      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskPWG4HighPtSpectra.C");
485      AliPWG4HighPtSpectra *taskPtSpectra = AddTaskPWG4HighPtSpectra();
486      if (!taskPtSpectra) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskPtSpectra cannot run for this train conditions - EXCLUDED");
487    }
488    if(iPWG4KMeans){
489      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskKMeans.C");
490      AliAnalysisTaskKMeans *taskKMeans = AddTaskKMeans();
491      if (!taskKMeans) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskKMenans cannot run for this train conditions - EXCLUDED");
492    }
493
494    if(iPWG4Cluster){
495      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJetCluster.C");
496      AliAnalysisTaskJetCluster *taskCl = 0;
497      if(iPWG4Cluster&1){
498        taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelection,"KT");
499      }
500      if(iPWG4Cluster&2){
501        UInt_t selection = 0;
502        if(!iAODanalysis) selection = 0xffffff;
503        else selection = 1<<0|1<<1|1<<2|1<<3|1<<4|1<<5|1<<7|1<<8|1<<9;
504        AddTaskJetClusterDelta(kHighPtFilterMask,kUseAODMC,iPhysicsSelection,"KT",selection);
505      }
506      if(iPWG4Cluster&4){
507        UInt_t selection = 0;
508        if(!iAODanalysis) selection = 0xffffff;
509        else selection = 1<<0|1<<1|1<<2|1<<3|1<<4|1<<5|1<<7|1<<8|1<<9;
510        taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelection,"ANTIKT");
511        AddTaskJetClusterDelta(kHighPtFilterMask,kUseAODMC,iPhysicsSelection,"ANTIKT",selection);
512      }
513
514
515      if (!taskCl) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskCluster cannot run for this train conditions - EXCLUDED");
516
517    }
518    if(iPWG4PartCorr){
519      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskPartCorr.C");
520      AliAnalysisTaskParticleCorrelation *taskpartcorrPHOS = AddTaskPartCorr("AOD", "PHOS",kFALSE,kIsMC);
521      if (!taskpartcorrPHOS) ::Warning("AnalysisTrainNew", "AliAnalysisTaskParticleCorrelation PHOS cannot run for this train conditions - EXCLUDED");
522      AliAnalysisTaskParticleCorrelation *taskpartcorrEMCAL = AddTaskPartCorr("AOD", "EMCAL",kFALSE,kIsMC);
523      if (!taskpartcorrEMCAL) ::Warning("AnalysisTrainNew", "AliAnalysisTaskParticleCorrelation EMCAL cannot run for this train conditions - EXCLUDED");
524      if(kDeltaAODPartCorrName.Length()>0)mgr->RegisterExtraFile(kDeltaAODPartCorrName.Data()); // hmm this is written anyway.... but at least we do not register it...
525    } 
526
527    if(iPWG4CaloQA){
528      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/QA/AddTaskCalorimeterQA.C");
529      AliAnalysisTaskParticleCorrelation *taskcaloQA =  AddTaskCalorimeterQA("ESD",kFALSE,kIsMC);
530      if(!taskcaloQA)::Warning("AnalysisTrainNew", "AliAnalysisTaskParticleCorrelation QA cannot run - EXCLUDED");
531    } 
532
533    if(iPWG4JetCorr){
534      //     using namespace JetCorrelHD;
535      TString cdir = gSystem->WorkingDirectory();
536      gSystem->ChangeDirectory(gSystem->ExpandPathName("$ALICE_ROOT/PWG4/macros/"));
537      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJetCorrel.C");
538      AliAnalysisTaskJetCorrel *taskjetcorr = AddTaskJetCorrel();
539      gSystem->ChangeDirectory(cdir);
540      if (!taskjetcorr) ::Warning("AnalysisTrainNew", "AliAnalysisTaskJetCorrel  cannot run for this train conditions - EXCLUDED");
541    } 
542
543    if(iPWG4Tagged){
544      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskTaggedPhotons.C");
545      AliAnalysisTaskTaggedPhotons * taskTagged = AddTaskTaggedPhotons(kFALSE); // EMCAL
546      taskTagged = AddTaskTaggedPhotons(kTRUE); // PHOS 
547      if (!taskTagged) ::Warning("AnalysisTrainNew", "AliAnalysisTaskTaggedPhotons  cannot run for this train conditions - EXCLUDED");     
548    }
549    if (iPWG4omega3pi) {
550      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskomega3pi.C");
551      AliAnalysisTaskOmegaPi0PiPi *taskomega3pi = AddTaskomega3pi();
552      if (!taskomega3pi) ::Warning("AnalysisTrainNew", "AliAnalysisTaskomega3pi cannot run\
553  for these train conditions - EXCLUDED");
554    }
555
556    // PWG4 gamma conversion analysis
557    if (iPWG4GammaConv) {
558       gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskGammaConversion.C");
559       TString cdir = gSystem->WorkingDirectory();
560       gSystem->ChangeDirectory(gSystem->ExpandPathName("$ALICE_ROOT/PWG4/macros/"));
561       //      TString gcArguments = "-run-on-train -run-jet -run-chic -run-neutralmeson -run-cf";
562       //      TString gcArguments = "-run-on-train -run-jet -run-neutralmeson -run-cf -use-own-xyz";
563       //      TString gcArguments = "-run-on-train -run-jet -run-neutralmeson -run-cf -use-own-xyz";
564       TString gcArguments = "-run-on-train -run-jet -run-omega-meson -run-neutralmeson";
565       TString kGCAnalysisCutSelectionId="9002111000";
566       gcArguments.Append(Form("-set-cut-selection  %s ",kGCAnalysisCutSelectionId.Data()));
567       if(!kIsMC)gcArguments += " -mc-off";
568       AliAnalysisTaskGammaConversion * taskGammaConversion = AddTaskGammaConversion(gcArguments,mgr->GetCommonInputContainer());
569       gSystem->ChangeDirectory(cdir);
570       taskGammaConversion->SelectCollisionCandidates();
571       if (!taskGammaConversion) ::Warning("AnalysisTrainNew", "AliAnalysisTaskGammaConversion cannot run for these train conditions - EXCLUDED");
572    }   
573
574
575    //==========================================================================
576    // FOR THE REST OF THE TASKS THE MACRO AddTaskXXX() is not yet implemented/
577    // Run the analysis
578    //    
579    if (kPluginUse) {
580       AliAnalysisGrid *alienHandler = CreateAlienHandler(plugin_mode);
581       AliAnalysisManager::GetAnalysisManager()->SetGridHandler(alienHandler);
582    }
583    
584    if (mgr->InitAnalysis()) {
585      mgr->PrintStatus();
586      // if (kSaveTrain || strlen(config_file)) gSystem->ChangeDirectory(kTrainName);
587      if (!strcmp(plugin_mode,"submit")&&smode=="GRID"){
588        TString alien_workdir = gGrid->GetHomeDirectory();
589        if (iAODanalysis) alien_workdir += "analysisAOD";
590        else              alien_workdir += "analysisESD";
591        if(kGridDataSet.Length()>0)alien_workdir += Form("/%s",kGridDataSet.Data());
592        AliAnalysisAlien *gridhandler = (AliAnalysisAlien*)mgr->GetGridHandler();
593        printf("=== AnalysisTrainPWG4Jets:: Registering jdl in the work directory alien://%s/%s, should be done by the manager! ===\n",
594               alien_workdir.Data(),gridhandler->GetGridOutputDir());
595
596        TString dest;
597        dest = Form("%s/%s/%s.jdl",alien_workdir.Data(),gridhandler->GetGridOutputDir(),kTrainName.Data());
598        if(AliAnalysisAlien::FileExists(dest.Data())){
599          //      Printf("%s exist on grid removing...",dest.Data());
600          //      gGrid->Rm(dest.Data());
601        }
602        TFile::Cp(Form("file:%s.jdl",kTrainName.Data()),Form("alien://%s",dest.Data()));
603        
604        dest = Form("%s/rootfiles/STEER/LQ1dRef_v1.root",gGrid->GetHomeDirectory());
605        if(AliAnalysisAlien::FileExists(dest.Data())){
606          Printf("%s exist on grid removing...",dest.Data());
607          gGrid->Rm(dest.Data());
608        }
609        TFile::Cp(Form("file:%s/STEER/LQ1dRef_v1.root",
610                       gSystem->ExpandPathName("$ALICE_ROOT")), 
611                  Form("alien://%s",dest.Data()));
612      }
613      AliLog::SetGlobalLogLevel(AliLog::kError);
614      if((kUseSysInfo>0&&smode=="LOCAL")||!strcmp(plugin_mode, "test")){
615        TFile * fM = TFile::Open("manager_local.root","RECREATE");
616        mgr->Write();
617        fM->Close();
618      }
619
620      StartAnalysis(smode, chain);
621        
622      if((kUseSysInfo>0&&smode=="LOCAL")||!strcmp(plugin_mode, "test")){
623        for(int i = 0;i < mgr->GetTopTasks()->GetEntries();i++){
624          mgr->ProfileTask(i);
625        }
626      }
627      if (!strcmp(plugin_mode, "offline")&&smode=="GRID"){
628        // Offline mode path files
629        //       PatchJDL();
630        PatchAnalysisMacro();
631      }
632
633      if (kSaveTrain && smode=="GRID") {
634        AliAnalysisAlien *gridhandler = (AliAnalysisAlien*)mgr->GetGridHandler();
635        TString alien_workdir = gGrid->GetHomeDirectory();
636        if (iAODanalysis) alien_workdir += "analysisAOD";
637        else              alien_workdir += "analysisESD";
638        if(kGridDataSet.Length()>0)alien_workdir += Form("/%s",kGridDataSet.Data());
639        //     kGridOutdir = gridhandler->GetGridOutputDir();
640        printf("=== Registering ConfigTrain.C in the work directory <%s> ===\n",
641                 alien_workdir.Data());
642        if (AliAnalysisAlien::FileExists(Form("%s/%sConfig.C", alien_workdir.Data(), kTrainName.Data())))
643          gGrid->Rm(Form("%s/%sConfig.C", alien_workdir.Data(), kTrainName.Data()));
644        if (strcmp(plugin_mode, "test"))
645          TFile::Cp(Form("file:%sConfig.C",kTrainName.Data()), Form("alien://%s/%sConfig.C", alien_workdir.Data(), kTrainName.Data()));
646      }
647    }
648 }
649
650 //______________________________________________________________________________
651 void StartAnalysis(const char *mode, TChain *chain) {
652 // Start analysis.
653    Int_t imode = -1;
654    AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
655    if (!strcmp(mode, "LOCAL")) imode = 0;
656    if (!strcmp(mode, "PROOF")) imode = 1;
657    if (!strcmp(mode, "GRID"))  imode = 2;
658    switch (imode) {
659       case 0:
660          if (!chain) {
661             ::Error("AnalysisTrainPWG4Jets.C::StartAnalysis", "Cannot create the chain");
662             return;
663          }   
664          mgr->StartAnalysis(mode, chain,kNumberOfEvents);
665          return;
666       case 1:
667          if (!kProofDataSet.Length()) {
668             ::Error("AnalysisTrainPWG4Jets.C::StartAnalysis", "kProofDataSet is empty");
669             return;
670          }   
671          mgr->StartAnalysis(mode, kProofDataSet, kProofEvents,kProofOffset);
672          return;
673       case 2:
674          if (kPluginUse) {
675             if (!mgr->GetGridHandler()) {
676                ::Error("AnalysisTrainPWG4Jets.C::StartAnalysis", "Grid plugin not initialized");
677                return;
678             }   
679             mgr->StartAnalysis("grid");
680          } else {
681             if (!chain) {
682                ::Error("AnalysisTrainPWG4Jets.C::StartAnalysis", "Cannot create the chain");
683                return;
684             }   
685             mgr->StartAnalysis(mode, chain);
686          }   
687          return;
688    }      
689 }          
690     
691 //______________________________________________________________________________
692 void CheckModuleFlags(const char *mode) {
693 // Checks selected modules and insure compatibility
694    Int_t imode = -1;
695    if (!strcmp(mode, "LOCAL")) imode = 0;
696    if (!strcmp(mode, "PROOF")) imode = 1;
697    if (!strcmp(mode, "GRID"))  imode = 2;
698
699
700    if (kUseCPAR) {
701      kPluginAliRootVersion    = ""; // NO aliroot if we use CPAR
702    }
703
704    if (imode==1) {
705       if (!kUsePAR) {
706          ::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PAR files enabled due to PROOF analysis");
707          kUsePAR = kTRUE;
708       }   
709    }  
710    if (imode != 2) {
711       ::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "AliEn plugin disabled since not in GRID mode");
712       kPluginUse = kFALSE; 
713    }   
714
715
716    if(!kIsMC){
717      // switch off anthin related to MC
718      kUseMC = 0;
719      kUseAODMC = 0;
720      kUseTR = kFALSE;
721    }
722
723    if (iAODanalysis) {
724    // AOD analysis
725       if (kUseMC)
726          ::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "MC usage disabled in analysis on AOD's");
727       if (kUseAODTags)
728          ::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "AOD tags usage disabled in analysis on AOD's");
729       kUseMC = kFALSE;
730       kUseTR = kFALSE;
731       kUseAODTags = kFALSE;
732       if (iESDfilter)
733          ::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "ESD filter disabled in analysis on AOD's");
734       iESDfilter   = 0;
735       if (iPhysicsSelection)
736          ::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "Physics Selection disabled in analysis on AOD's");
737       iPhysicsSelection   = 0;
738       if (!iAODhandler) {
739          if (iJETAN) 
740             ::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "JETAN disabled in analysis on AOD's without AOD handler");
741          iJETAN = 0;
742          iDIJETAN = 0;
743       }
744       // Disable tasks that do not work yet on AOD data
745       if(iPWG4JCORRAN)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG4 JCORRAN disabled in analysis on AOD's");
746       iPWG4JCORRAN = 0;
747       if( iPWG4PtQAMC)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG4 PtQAMC disabled in analysis on AOD's");
748       iPWG4PtQAMC        = 0;
749       if( iPWG4PtQATPC)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG4 PtTPC disabled in analysis on AOD's");
750       iPWG4PtQATPC        = 0;
751       if( iPWG4Cosmics)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG4 Comics disabled in analysis on AOD's");
752       iPWG4Cosmics        = 0;
753
754       if( iPWG4PtSpectra)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG4 PtQAMC disabled in analysis on AOD's");
755       iPWG4PtSpectra     = 0;
756       if(iPWG4KMeans)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG4KMeans disabled on AOD's");
757       iPWG4KMeans       = 0;
758       if (iPWG4JetCorr)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG4Jetcorr disabled on AOD's");
759       iPWG4JetCorr = 0;
760       if (iPWG4PartCorr)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG4partcorr disabled on AOD's");
761       iPWG4PartCorr = 0;
762       if (iPWG4CaloQA)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG4CaloQA disabled on AOD's");
763       iPWG4CaloQA = 0;
764       if (iPWG4Tagged)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG4tagged disabled on AOD's");
765       iPWG4Tagged = 0;
766       if (iPWG4omega3pi)
767         ::Info("AnalysisTrainNew.C::CheckModuleFlags", "PWG4omega3pi disabled on AOD's");
768       iPWG4omega3pi = 0;
769       if(iPWG1QASym)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG1 QA Sym disabled in analysis on AOD's");
770       if (iPWG4GammaConv)::Info("AnalysisPWG4Jets.C::CheckModuleFlags", "PWG4gammaconv disabled on AOD's");
771       iPWG4GammaConv = 0;   
772       iPWG1QASym     = 0;
773    } else {   
774    // ESD analysis
775      if (!kUseMC){
776        kUseTR = kFALSE;
777        
778        if(kUseKinefilter)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG4 Kine Filter disabled in analysis without MC");
779        kUseKinefilter = kFALSE;
780        if( iPWG4PtQAMC)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG4 PtQAMC disabled in analysis without MC");
781        iPWG4PtQAMC        = 0;
782
783      }
784      if (!kUseTR) {
785        if(iPWG4PtQAMC)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "iPWG4QATPCMC disabled if not reading track references");
786        iPWG4PtQAMC        = 0;
787      }   
788      if (iJETAN){
789        iESDfilter=1;
790      }
791       if (!iESDfilter){
792         kUseKinefilter = kFALSE;
793         kUseMuonfilter = kFALSE;
794       }
795       if(!iJETAN){
796         iPWG4JetSpectrum = iPWG4UE = iPWG4ThreeJets = iDIJETAN = 0;
797       }
798    }
799    iPWG4JetTasks = iPWG4JetServices||iPWG4JetSpectrum||iPWG4UE||iPWG4PtQAMC||iPWG4PtSpectra||iPWG4PtQATPC||iPWG4Cosmics||iPWG4ThreeJets||iPWG4JetChem;
800    iPWG4PartCorrLibs = iPWG4PartCorr||iPWG4Tagged||iPWG4CaloQA;
801    iJETANLib = iPWG4JetTasks||iJETAN||iDIJETAN;
802    if (iESDfilter) {iAODhandler=1;}
803    if (kUseKinefilter && !kUseMC) kUseKinefilter = kFALSE;
804    if (kUseAODTags && !iAODhandler) kUseAODTags = kFALSE;
805
806
807    
808 }
809
810 //______________________________________________________________________________
811 Bool_t Connect(const char *mode) {
812 // Connect <username> to the back-end system.
813    Int_t imode = -1;
814    if (!strcmp(mode, "LOCAL")) imode = 0;
815    if (!strcmp(mode, "PROOF")) imode = 1;
816    if (!strcmp(mode, "GRID"))  imode = 2;
817    TString username = gSystem->Getenv("alien_API_USER");
818    switch (imode) {
819       case 0:
820          break;
821       case 1:
822          if  (!username.Length()) {
823             ::Error(Form("AnalysisTrainPWG4Jets.C::Connect <%s>", mode), "Make sure you:\n \
824                            1. Have called: alien-token-init <username>\n \
825                            2. Have called: >source /tmp/gclient_env_$UID");
826             return kFALSE;
827          }
828          ::Info("AnalysisTrainPWG4Jets.C::Connect", "Connecting user <%s> to PROOF cluster <%s>", 
829                 username.Data(), kProofCluster.Data());
830          gEnv->SetValue("XSec.GSI.DelegProxy", "2");
831 //         TProof::Open(Form("%s@%s:31093", username.Data(), kProofCluster.Data()));       
832          TProof::Open(Form("%s@%s", username.Data(), kProofCluster.Data()));       
833          if (!gProof) {
834             if (strcmp(gSystem->Getenv("XrdSecGSISRVNAMES"), "lxfsrd0506.cern.ch"))
835                ::Error(Form("AnalysisTrainPWG4Jets.C::Connect <%s>", mode), "Environment XrdSecGSISRVNAMES different from lxfsrd0506.cern.ch");
836             return kFALSE;
837          }
838          if(kProofClearPackages)gProof->ClearPackages();
839
840          if(kProofSaveToAlien){
841            TGrid::Connect("alien://");
842            if (gGrid) {
843              TString homedir = gGrid->GetHomeDirectory();
844              TString workdir = homedir + kTrainName;
845              if (!gGrid->Cd(workdir)) {
846                gGrid->Cd(homedir);
847                if (gGrid->Mkdir(workdir)) {
848                  gGrid->Cd(kTrainName);
849                  ::Info("AnalysisTrainPWG4Jets::Connect()", "Directory %s created", gGrid->Pwd());
850                }
851              }
852              gGrid->Mkdir("proof_output");
853              gGrid->Cd("proof_output");
854              kProofOutdir = Form("alien://%s", gGrid->Pwd());
855            }   
856          }
857          break;
858       case 2:      
859          if  (!username.Length()) {
860             ::Error(Form("AnalysisTrainPWG4Jets.C::Connect <%s>", mode), "Make sure you:\n \
861                            1. Have called: alien-token-init <username>\n \
862                            2. Have called: >source /tmp/gclient_env_$UID");
863             return kFALSE;
864          }
865          if (kPluginUse && !gSystem->Getenv("alien_CLOSE_SE")) {
866             ::Error(Form("AnalysisTrainPWG4Jets.C::Connect <%s>", mode), 
867                            "When using the AliEn plugin it is preferable to define the \
868                            variable alien_CLOSE_SE in your environment.");
869             return kFALSE;
870          }
871          ::Info("AnalysisTrainPWG4Jets.C::Connect", "Connecting user <%s> to AliEn ...", 
872                 username.Data());
873          TGrid::Connect("alien://");
874          if (!gGrid || !gGrid->IsConnected()) return kFALSE;
875          break;
876       default:
877          ::Error("AnalysisTrainPWG4Jets.C::Connect", "Unknown run mode: %s", mode);
878          return kFALSE;
879    }
880    ::Info("AnalysisTrainPWG4Jets.C::Connect","Connected in %s mode", mode);
881    return kTRUE;
882 }
883
884 //______________________________________________________________________________
885 Bool_t LoadCommonLibraries(const char *mode)
886 {
887 // Load common analysis libraries.
888    Int_t imode = -1;
889    if (!strcmp(mode, "LOCAL")) imode = 0;
890    if (!strcmp(mode, "PROOF")) imode = 1;
891    if (!strcmp(mode, "GRID"))  imode = 2;
892    if (!gSystem->Getenv("ALICE_ROOT")) {
893       ::Error("AnalysisTrainPWG4Jets.C::LoadCommonLibraries", "Analysis train requires that analysis libraries are compiled with a local AliRoot"); 
894       return kFALSE;
895    }   
896    Bool_t success = kTRUE;
897    // ROOT libraries
898    gSystem->Load("libTree.so");
899    gSystem->Load("libGeom.so");
900    gSystem->Load("libVMC.so");
901    gSystem->Load("libPhysics.so");
902    
903    // Load framework classes. Par option ignored here.
904    switch (imode) {
905       case 0:
906       case 2:
907          if (kUseCPAR) {
908             success &= LoadLibrary("STEERBase", mode, kTRUE);
909             success &= LoadLibrary("ESD", mode, kTRUE);
910             success &= LoadLibrary("AOD", mode, kTRUE);
911             success &= LoadLibrary("ANALYSIS", mode, kTRUE);
912             success &= LoadLibrary("ANALYSISalice", mode, kTRUE);
913             success &= LoadLibrary("CORRFW", mode, kTRUE);
914          } else {   
915             success &= LoadLibrary("libSTEERBase.so", mode);
916             success &= LoadLibrary("libESD.so", mode);
917             success &= LoadLibrary("libAOD.so", mode);
918             success &= LoadLibrary("libANALYSIS.so", mode);
919             success &= LoadLibrary("libANALYSISalice.so", mode);
920             success &= LoadLibrary("libCORRFW.so", mode);
921             gROOT->ProcessLine(".include $ALICE_ROOT/include");
922          }   
923          break;
924       case 1:
925          Int_t ires = -1;
926          if (kProofUseAFPAR && !gSystem->AccessPathName(kProofAFversion)) ires = gProof->UploadPackage(kProofAFversion);
927          if (ires < 0) {
928             success &= LoadLibrary("STEERBase", mode);
929             success &= LoadLibrary("ESD", mode);
930             success &= LoadLibrary("AOD", mode);
931             success &= LoadLibrary("ANALYSIS", mode);
932             success &= LoadLibrary("ANALYSISalice", mode);
933             success &= LoadLibrary("CORRFW", mode);
934          } else { 
935             ires = gProof->EnablePackage(kProofAFversion);
936             if (ires<0) success = kFALSE;
937             success &= LoadLibrary("CORRFW", mode);
938          }
939          break;         
940       default:
941          ::Error("AnalysisTrainPWG4Jets.C::LoadCommonLibraries", "Unknown run mode: %s", mode);
942          return kFALSE;
943    }
944    if (success) {
945       ::Info("AnalysisTrainPWG4Jets.C::LoadCommodLibraries", "Load common libraries:    SUCCESS");
946       ::Info("AnalysisTrainPWG4Jets.C::LoadCommodLibraries", "Include path for Aclic compilation:\n%s",
947               gSystem->GetIncludePath());
948    } else {           
949       ::Info("AnalysisTrainPWG4Jets.C::LoadCommodLibraries", "Load common libraries:    FAILED");
950    }   
951       
952    return success;
953 }
954
955 //______________________________________________________________________________
956 Bool_t LoadAnalysisLibraries(const char *mode)
957 {
958 // Load common analysis libraries.
959    Bool_t success = kTRUE;
960    if (iESDfilter) {
961       if (!LoadLibrary("PWG3base", mode, kTRUE) ||
962           !LoadLibrary("PWG3muon", mode, kTRUE)) return kFALSE;
963    }   
964    // JETAN
965    if (iJETANLib) {
966      // this part needs some rework in case we do not need the fastjed finders for processing
967      if (!LoadLibrary("JETAN", mode, kTRUE)) return kFALSE;
968      if (!strcmp(mode, "PROOF")){
969        gProof->Exec("gSystem->Load\(\"/afs/cern.ch/user/d/dperrino/public/libCGAL.so\"\)", kTRUE); 
970        gProof->Exec("gSystem->Load\(\"/afs/cern.ch/user/d/dperrino/public/libfastjet.so\"\)", kTRUE); 
971        // problem when loading siscone copiled with different gcc version??
972        // gProof->Exec("gSystem->Load\(\"/afs/cern.ch/user/d/dperrino/public/libsiscone.so\"\)", kTRUE); 
973        gProof->Exec("gSystem->Load\(\"/afs/cern.ch/user/d/dperrino/public/libSISConePlugin.so\"\)", kTRUE);      
974      }
975      if(!kUsePAR){ 
976        if (!LoadLibrary("CGAL", mode, kTRUE)) return kFALSE;
977        if (!LoadLibrary("fastjet", mode, kTRUE)) return kFALSE;
978        if (!LoadLibrary("siscone", mode, kTRUE)) return kFALSE;
979        if (!LoadLibrary("SISConePlugin", mode, kTRUE)) return kFALSE;
980      }
981      else{
982        // par files plus FASTJET needs some extra work... need to change
983        // the loading sequence in the auto generated .C file
984        if (!LoadLibrary("libCGAL.so", mode, kTRUE)) return kFALSE;
985        if (!LoadLibrary("libfastjet.so", mode, kTRUE)) return kFALSE;
986        if (!LoadLibrary("libsiscone.so", mode, kTRUE)) return kFALSE;
987        if (!LoadLibrary("libSISConePlugin.so", mode, kTRUE)) return kFALSE;
988      }
989      if (!LoadLibrary("FASTJETAN", mode, kTRUE)) return kFALSE;
990    }
991    if(iPWG4JetTasks){
992      if (!LoadLibrary("PWG4JetTasks", mode, kTRUE)) return kFALSE;
993    }
994    if(iPWG4JCORRAN){
995      // PWG4 particle correlations
996      if(!LoadLibrary("PWG4JCORRAN",mode,kTRUE))return kFALSE;
997    }
998
999    if(iPWG1QASym){
1000      if (!LoadSource(Form("%s/PWG1/AliAnalysisTaskQASym.cxx",gSystem->ExpandPathName("$ALICE_ROOT")), mode, kTRUE))return kFALSE;
1001    }
1002    if(iPWG4TmpSourceSara){
1003      if(!kUsePAR)gSystem->AddIncludePath("-I$ALICE_ROOT/include/JetTasks"); // ugly hack!!
1004      if(!LoadSource(Form("%s/PWG4/JetTasks/AliAnalysisTaskEta.cxx",gSystem->ExpandPathName("$ALICE_ROOT")), mode, kTRUE))return kFALSE;
1005    }
1006    if(iPWG4TmpSourceFrag){
1007      if(!kUsePAR)gSystem->AddIncludePath("-I$ALICE_ROOT/include/JetTasks"); // ugly hack!!
1008      if(!LoadSource(Form("%s/PWG4/JetTasks/AliAnalysisTaskFragFunc.cxx",gSystem->ExpandPathName("$ALICE_ROOT")), mode, kTRUE))return kFALSE;
1009    }
1010
1011
1012    /*
1013    if(iPWG4JetChem){
1014      if(!kUsePAR)gSystem->AddIncludePath("-I$ALICE_ROOT/include/JetTasks"); // ugly hack!!
1015      if(!LoadSource(Form("%s/PWG4/JetTasks/AliAnalysisTaskJetChem.cxx",gSystem->ExpandPathName("$ALICE_ROOT")), mode, kTRUE))return kFALSE;
1016    }
1017    */
1018
1019    if (iPWG4PartCorrLibs) {   
1020       if (!LoadLibrary("EMCALUtils", mode, kTRUE) ||
1021           !LoadLibrary("PHOSUtils", mode, kTRUE) ||
1022           !LoadLibrary("PWG4PartCorrBase", mode, kTRUE) ||
1023           !LoadLibrary("PWG4PartCorrDep", mode, kTRUE)) return kFALSE;
1024    }
1025    if (iPWG4JetCorr) { 
1026      if (!LoadLibrary("PWG4JetCorrel", mode, kTRUE)) return kFALSE;
1027    }  
1028    if (iPWG4omega3pi) {
1029      if (!LoadLibrary("PWG4omega3pi", mode, kTRUE)) return kFALSE;
1030    }
1031    if (iPWG4GammaConv) {
1032       if (!LoadLibrary("PWG4GammaConv", mode, kTRUE)) return kFALSE;
1033    }      
1034
1035    ::Info("AnalysisTrainPWG4Jets.C::LoadAnalysisLibraries", "Load other libraries:   SUCCESS");
1036    return kTRUE;
1037 }
1038
1039 //______________________________________________________________________________
1040 Bool_t LoadLibrary(const char *module, const char *mode, Bool_t rec=kFALSE)
1041 {
1042 // Load a module library in a given mode. Reports success.
1043    Int_t imode = -1;
1044    Int_t result;
1045    TString smodule(module);
1046    if (!strcmp(mode, "LOCAL")) imode = 0;
1047    if (!strcmp(mode, "PROOF")) imode = 1;
1048    if (!strcmp(mode, "GRID"))  imode = 2;
1049    TString mod(module);
1050    if (!mod.Length()) {
1051       ::Error("AnalysisTrainPWG4Jets.C::LoadLibrary", "Empty module name");
1052       return kFALSE;
1053    }   
1054    // If a library is specified, just load it
1055    if (smodule.EndsWith(".so")) {
1056       mod.Remove(mod.Index(".so"));
1057       result = gSystem->Load(mod);
1058       if (result < 0) {
1059          ::Error("AnalysisTrainPWG4Jets.C::LoadLibrary", "Could not load library %s", module);
1060          return kFALSE;
1061       }
1062       if (rec) anaLibs += Form("%s.so ",mod.Data()); 
1063       if (rec) anaLibsExtra += Form("%s.so ",mod.Data()); 
1064       return kTRUE;
1065    } 
1066    // Check if the library is already loaded
1067    if (strlen(gSystem->GetLibraries(Form("%s.so", module), "", kFALSE)) > 0)
1068       return kTRUE;    
1069    switch (imode) {
1070       case 0:
1071       case 2:
1072          if (kUsePAR) {
1073             result = SetupPar(module);
1074             if (rec) anaPars += Form("%s.par ", module);
1075          } else {
1076             result = gSystem->Load(Form("lib%s.so", module));
1077             if (rec) anaLibs += Form("lib%s.so ", module);
1078          }   
1079          break;
1080       case 1:
1081         if(!gSystem->AccessPathName(module)){
1082           ::Info("AnalysisTrainPWG4Jets.C::LoadLibrary", "Removing directory %s",module);
1083           gSystem->Exec(Form("rm -rf %s",module));
1084         }
1085          result = gProof->UploadPackage(module);
1086          if (result<0) {
1087             result = gProof->UploadPackage(gSystem->ExpandPathName(Form("$ALICE_ROOT/%s.par", module)));
1088             if (result<0) {
1089                ::Error("AnalysisTrainPWG4Jets.C::LoadLibrary", "Could not find module %s.par in current directory nor in $ALICE_ROOT", module);
1090                return kFALSE;
1091             }
1092          }   
1093          result = gProof->EnablePackage(module);
1094          break;
1095       default:
1096          return kFALSE;
1097    }         
1098    if (result < 0) {
1099       ::Error("AnalysisTrainPWG4Jets.C::LoadLibrary", "Could not load module %s", module);
1100       return kFALSE;
1101    }
1102    return kTRUE;
1103 }           
1104
1105
1106
1107 //______________________________________________________________________________
1108 Bool_t LoadSource(const char *source, const char *mode, Bool_t rec=kFALSE)
1109 {
1110 // Load a module library in a given mode. Reports success.
1111    Int_t imode = -1;
1112    Int_t result = -1;
1113    if (!strcmp(mode, "LOCAL")) imode = 0;
1114    if (!strcmp(mode, "PROOF")) imode = 1;
1115    if (!strcmp(mode, "GRID"))  imode = 2;
1116    TString ssource(source);
1117    TString basename = gSystem->BaseName(ssource.Data());
1118    if (!ssource.Length()) {
1119       ::Error("AnalysisTrainPWG4Jets.C::LoadSource", "Empty task name");
1120       return kFALSE;
1121    }   
1122    // we have a source code so compile it
1123    if (ssource.EndsWith(".cxx")) {
1124      // need to copy it here other wise the path is also used on grid...
1125      ssource.Remove(ssource.Index(".cxx"));
1126      basename.Remove(basename.Index(".cxx"));
1127      Printf("LoadSources:: Copying...  path %s{cxx,h}",ssource.Data());
1128      gSystem->Exec(Form("cp %s.cxx . ",ssource.Data()));
1129      gSystem->Exec(Form("cp %s.h . ",ssource.Data()));
1130      // Path to code
1131      // only needed for local compilation, in grid and proof mode 
1132      // the task headers are uploaded 
1133      //     path.Remove(path.Index(gSystem->BaseName(path.Data())));
1134      // Printf("LoadSources:: Including path %s",path.Data());
1135      //  if(path.Length()>0)gROOT->ProcessLine(Form(".include %s",path.Data()));
1136      Printf("LoadSources:: Loading...  path %s",basename.Data());
1137      switch (imode) {
1138      case 0:
1139        result = gROOT->LoadMacro(Form("%s.cxx++g",basename.Data()));
1140        break;
1141      case 1:
1142        result = gProof->LoadMacro(Form("%s.cxx++g",basename.Data()));
1143        break;
1144      case 2:
1145        result = gROOT->LoadMacro(Form("%s.cxx++g",basename.Data()));
1146        if (rec){
1147          // what we want to compile
1148          anaSources += Form("%s.cxx ",basename.Data()); 
1149          // what we need as input...
1150          anaLibs += Form("%s.cxx %s.h ",basename.Data(),basename.Data()); 
1151        }
1152        break;
1153      default:
1154        return kFALSE;
1155      }
1156    } 
1157    if (result < 0) {
1158       ::Error("AnalysisTrainPWG4Jets.C::LoadSources", "Could not load source %s", source);
1159       return kFALSE;
1160    }
1161    return kTRUE;
1162 }           
1163
1164
1165 //______________________________________________________________________________
1166 TChain *CreateChain(const char *mode, const char *plugin_mode)
1167 {
1168 // Create the input chain
1169    Int_t imode = -1;
1170    if (!strcmp(mode, "LOCAL")) imode = 0;
1171    if (!strcmp(mode, "PROOF")) imode = 1;
1172    if (!strcmp(mode, "GRID"))  imode = 2;
1173    TChain *chain = NULL;
1174    // Local chain
1175    switch (imode) {
1176       case 0:
1177          if (iAODanalysis) {
1178             if (!kLocalXMLDataset.Length()) {
1179                // Local AOD
1180                chain = new TChain("aodTree");
1181                TString line;
1182                ifstream in;
1183                in.open(kLocalDataList.Data());
1184                while (in.good()) {
1185                  in >> line;
1186                  if (line.Length() == 0) continue;
1187                  // cout << " line = " << line << endl;
1188                  chain->Add(line.Data());
1189                }       
1190             } else {
1191                // Interactive AOD
1192                chain = CreateChainSingle(kLocalXMLDataset, "aodTree");
1193             }
1194          } else {      
1195            if (!kLocalXMLDataset.Length()) {
1196              // Local ESD
1197              chain = new TChain("esdTree");
1198              TString line;
1199              ifstream in;
1200              in.open(kLocalDataList.Data());
1201              while (in.good()) {
1202                in >> line;
1203                if (line.Length() == 0) continue;
1204                cout << " line = " << line << endl;
1205                chain->Add(line.Data());
1206              }       
1207            } else {
1208              // Interactive ESD
1209                chain = CreateChainSingle(kLocalXMLDataset, "esdTree");
1210            }   
1211          }
1212          break;
1213       case 1:
1214          break;
1215       case 2:
1216          if (kPluginUse) {
1217 //            AliAnalysisGrid *alienHandler = CreateAlienHandler(plugin_mode);
1218 //            AliAnalysisManager::GetAnalysisManager()->SetGridHandler(alienHandler);
1219          } else {
1220             TString           treeName = "esdTree";
1221             if (iAODanalysis) treeName = "aodTree";
1222             chain = CreateChainSingle("wn.xml", treeName);
1223          }
1224          break;      
1225       default:   
1226    }
1227    if (chain && chain->GetNtrees()) return chain;
1228    return NULL;
1229 }   
1230
1231 //______________________________________________________________________________
1232 TChain* CreateChainSingle(const char* xmlfile, const char *treeName)
1233 {
1234    printf("*******************************\n");
1235    printf("*** Getting the ESD Chain   ***\n");
1236    printf("*******************************\n");
1237    TAlienCollection * myCollection  = TAlienCollection::Open(xmlfile);
1238
1239    if (!myCollection) {
1240       ::Error("AnalysisTrainPWG4Jets.C::CreateChainSingle", "Cannot create an AliEn collection from %s", xmlfile) ;
1241       return NULL ;
1242    }
1243
1244    TChain* chain = new TChain(treeName);
1245    myCollection->Reset() ;
1246    while ( myCollection->Next() ) chain->Add(myCollection->GetTURL("")) ;
1247    chain->ls();
1248    return chain;
1249 }
1250
1251 //______________________________________________________________________________
1252 Int_t SetupPar(char* pararchivename)
1253 {
1254    if (!pararchivename || !strlen(pararchivename)) return -1;
1255    char processline[1024];
1256    if (gSystem->AccessPathName(Form("%s.par", pararchivename))) {
1257       if (!gSystem->AccessPathName(Form("%s/%s.par", gSystem->Getenv("ALICE_ROOT"),pararchivename))) {
1258          ::Info("AnalysisTrainPWG4Jets.C::SetupPar", "Getting %s.par from $ALICE_ROOT", pararchivename);
1259          TFile::Cp(gSystem->ExpandPathName(Form("$ALICE_ROOT/%s.par", pararchivename)), 
1260                    Form("%s.par",pararchivename));
1261       } else {
1262          ::Error("AnalysisTrainPWG4Jets.C::SetupPar", "Cannot find %s.par", pararchivename);
1263          return -1;
1264       }   
1265    }
1266    if (kPluginUse && kSaveTrain) gSystem->Exec(Form("ln -s ../%s.par %s",pararchivename, kTrainName.Data()));
1267    gSystem->Exec(Form("tar xvzf %s.par", pararchivename));
1268
1269    TString ocwd = gSystem->WorkingDirectory();
1270    if (!gSystem->ChangeDirectory(pararchivename)) return -1;
1271         
1272    // check for BUILD.sh and execute
1273    if (!gSystem->AccessPathName("PROOF-INF/BUILD.sh")) {
1274       printf("*******************************\n");
1275       printf("*** Building PAR archive    ***\n");
1276       printf("*******************************\n");          
1277       if (gSystem->Exec("PROOF-INF/BUILD.sh")) {
1278          Error("runProcess","Cannot Build the PAR Archive! - Abort!");
1279          return -1;
1280       }
1281    }
1282
1283         // check for SETUP.C and execute
1284         if (!gSystem->AccessPathName("PROOF-INF/SETUP.C")) {
1285             printf("*******************************\n");
1286             printf("*** Setup PAR archive       ***\n");
1287             printf("*******************************\n");
1288             gROOT->Macro("PROOF-INF/SETUP.C");
1289         }       
1290         if (!gSystem->ChangeDirectory(ocwd.Data())) return -1;
1291    return 0;
1292 }
1293
1294 //______________________________________________________________________________
1295 AliAnalysisAlien* CreateAlienHandler(const char *plugin_mode)
1296 {
1297 // Check if user has a valid token, otherwise make one. This has limitations.
1298 // One can always follow the standard procedure of calling alien-token-init then
1299 //   source /tmp/gclient_env_$UID in the current shell.
1300    if (!AliAnalysisGrid::CreateToken()) return NULL;
1301    AliAnalysisAlien *plugin = new AliAnalysisAlien();
1302 // Set the run mode (can be "full", "test", "offline", "submit" or "terminate")
1303    plugin->SetRunMode(plugin_mode);
1304    if (kPluginUseProductionMode) plugin->SetProductionMode();
1305    plugin->SetJobTag(kJobTag);
1306    plugin->SetNtestFiles(2);
1307 //   plugin->SetPreferedSE("ALICE::NIHAM::File");
1308 // Set versions of used packages
1309    plugin->SetAPIVersion("V1.1x");
1310    //   plugin->SetAPIVersion("V1.0x");
1311 //   plugin->SetAPIVersion("V2.4");
1312    plugin->SetROOTVersion(kPluginRootVersion);
1313    plugin->SetAliROOTVersion(kPluginAliRootVersion);
1314 // Declare input data to be processed.
1315 // Method 1: Create automatically XML collections using alien 'find' command.
1316 // Define production directory LFN
1317    plugin->SetGridDataDir(kGridDatadir.Data());
1318 // Set data search pattern
1319    if (iAODanalysis) plugin->SetDataPattern(" *AliAOD.root");
1320    else              plugin->SetDataPattern(Form(" %s/*/*ESD.tag.root",kGridPassPattern.Data()));
1321 // ...then add run numbers to be considered
1322 //   plugin->SetRunRange(kGridRunRange[0], kGridRunRange[1]);
1323    for (Int_t i=kGridRunRange[0]; i<=kGridRunRange[1]; i++) {
1324      Printf("AnalysisTrainPWG4Jets Adding run number %s", Form(kGridRunPattern.Data(),i));
1325      plugin->AddRunNumber(Form(kGridRunPattern.Data(),i));
1326    }   
1327
1328    if(kGridLocalRunList.Length()>0){
1329      ifstream in1;
1330      in1.open(kGridLocalRunList.Data());
1331      int iRun;
1332
1333      /*
1334      char c;
1335      char cLine[250];
1336      while(!in1.eof()){
1337        c = in1.get();
1338        if ( (c >= '0') && (c <= '9') )
1339          {
1340            in1.putback (c);
1341            in1>>iRun;
1342            Printf("AnalysisTrainPWG4Jets Adding run number from File %s", Form(kGridRunPattern.Data(),iRun));
1343            plugin->AddRunNumber(Form(kGridRunPattern.Data(),iRun));
1344        }
1345      else
1346        {
1347          in1.putback (c);
1348          in1.getline(cLine,250);
1349
1350        }
1351      }
1352      */
1353
1354      // just use run numbers, negatives will be excluded
1355      while(in1>>iRun){
1356        if(iRun>0){
1357            Printf("AnalysisTrainPWG4Jets Adding run number from File %s", Form(kGridRunPattern.Data(),iRun));
1358            plugin->AddRunNumber(Form(kGridRunPattern.Data(),iRun));
1359        }
1360        else{
1361          Printf("AnalysisTrainPWG4Jets Skipping run number from File %d", iRun);
1362        }
1363      }
1364    }
1365
1366 // Method 2: Declare existing data files (raw collections, xml collections, root file)
1367 // If no path mentioned data is supposed to be in the work directory (see SetGridWorkingDir())
1368 // XML collections added via this method can be combined with the first method if
1369 // the content is compatible (using or not tags)
1370 //   plugin->AddDataFile("tag.xml");
1371 //   plugin->AddDataFile("/alice/data/2008/LHC08c/000057657/raw/Run57657.Merged.RAW.tag.root");
1372 // Define alien work directory where all files will be copied. Relative to alien $HOME.
1373    TString alien_workdir = "";
1374    
1375    if (iAODanalysis)  alien_workdir += "analysisAOD";
1376    else               alien_workdir += "analysisESD";    
1377    if(kGridDataSet.Length()>0)alien_workdir += Form("/%s",kGridDataSet.Data());
1378    plugin->SetGridWorkingDir(alien_workdir.Data());
1379
1380    // Declare alien output directory. Relative to working directory.
1381    if (!kGridOutdir.Length()) kGridOutdir = Form("output_%s",kTrainName.Data());
1382    plugin->SetGridOutputDir(kGridOutdir);
1383
1384    // Add external packages
1385    if (iJETAN||iDIJETAN) {
1386       plugin->AddExternalPackage("boost::v1_38_0");
1387       plugin->AddExternalPackage("cgal::v3.3.1");
1388       plugin->AddExternalPackage("fastjet::v2.4.0");
1389    }   
1390
1391
1392    // set extra libs before par file compilation
1393    anaLibs += kGridExtraFiles;
1394    anaLibs     = anaLibs.Strip();   
1395    Printf("anaLibs %s",anaLibs.Data());
1396    Printf("anaLibsExtra %s",anaLibsExtra.Data());
1397
1398    if (anaLibs.Length())          plugin->SetAdditionalLibs(anaLibs.Data());
1399    if (anaLibsExtra.Length())     plugin->SetAdditionalRootLibs(anaLibsExtra.Data());
1400
1401    TString ana_sources = "";
1402    TString ana_add = "";
1403    if (kUsePAR && anaPars.Length()) {
1404       printf("%s\n", anaPars.Data());
1405       TObjArray *arr;
1406       TObjString *objstr;
1407       arr = anaPars.Tokenize(" ");
1408       TIter next(arr);
1409       while ((objstr=(TObjString*)next())) plugin->EnablePackage(objstr->GetString());
1410       delete arr;
1411    } 
1412    
1413 // Declare the analysis source files names separated by blancs. To be compiled runtime
1414 // using ACLiC on the worker nodes.
1415    ana_sources = anaSources.Strip();
1416 // Declare all libraries (other than the default ones for the framework. These will be
1417 // loaded by the generated analysis macro. Add all extra files (task .cxx/.h) here.
1418
1419    if (ana_sources.Length()) plugin->SetAnalysisSource(ana_sources);
1420    plugin->SetExecutableCommand(kPluginExecutableCommand.Data());  
1421 // Declare the output file names separated by blancs.
1422 // (can be like: file.root or file.root@ALICE::Niham::File)
1423    plugin->SetDefaultOutputs();
1424    plugin->SetMergeExcludes(kGridMergeExclude);
1425    plugin->SetMaxMergeFiles(kGridMaxMergeFiles);
1426    plugin->SetNrunsPerMaster(kGridRunsPerMaster);
1427    plugin->SetMergeViaJDL(kPluginMergeViaJDL);
1428 // Use fastread option
1429    plugin->SetFastReadOption(kPluginFastReadOption);
1430 // UseOverwrite mode
1431    plugin->SetOverwriteMode(kPluginOverwriteMode); 
1432 // Optionally define the files to be archived.
1433 //   plugin->SetOutputArchive("log_archive.zip:stdout,stderr@ALICE::NIHAM::File root_archive.zip:AliAOD.root,AOD.tag.root@ALICE::NIHAM::File");
1434    plugin->SetOutputToRunNo(kPluginOutputToRunNumber);     // write the output to subdirs named after run number
1435    
1436    // Put default output files to archive
1437    TString listhists = "";
1438    TString listaods  = "";
1439    AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
1440    TIter next(mgr->GetOutputs());
1441    AliAnalysisDataContainer *output;
1442    while ((output=(AliAnalysisDataContainer*)next())) {
1443       const char *filename = output->GetFileName();
1444       if (!(strcmp(filename, "default"))) {
1445         if (!mgr->GetOutputEventHandler()) continue;
1446          filename = mgr->GetOutputEventHandler()->GetOutputFileName();
1447          if (listaods.Length()) listaods += " ";
1448          listaods += filename;
1449       } else {
1450         if(!listhists.Contains(filename)){
1451           if (listhists.Length()) listhists += " ";
1452           listhists += filename;
1453         }
1454       }
1455    }
1456
1457    if(kUseSysInfo>0){
1458      if (listhists.Length()) listhists += " ";
1459      listhists += "syswatch.root";
1460    }
1461
1462    if(kIsMC){
1463      if (listaods.Length()) listaods += " ";
1464      listaods += "pyxsec_hists.root";
1465    }
1466
1467
1468    if (mgr->GetExtraFiles().Length()) {
1469      if (listaods.Length()) listaods += " ";
1470      listaods += mgr->GetExtraFiles();
1471    }
1472
1473    // if we do not fill the aod we do not need to store it
1474    kGridMergeExclude = listaods;
1475    
1476    if(!kFillAOD){
1477      listaods="";
1478      plugin->SetDefaultOutputs(kFALSE);
1479      plugin->SetOutputFiles(listhists.Data());
1480    }
1481
1482
1483    listaods.ReplaceAll(" ", ",");
1484    listhists.ReplaceAll(" ", ",");
1485    if (listhists.Length()) listhists = Form("hist_archive.zip:%s@%s", listhists.Data(), kGridOutputStorages.Data());;
1486    if (listaods.Length())  listaods  = Form("aod_archive.zip:%s@%s", listaods.Data(), kGridOutputStorages.Data());;
1487
1488    if (!listhists.Length() && !listaods.Length()) {
1489       ::Fatal("AnalysisTrainPWG4Jets", "No task output !");
1490    }
1491
1492
1493
1494    TString outputArchive = "log_archive.zip:stdout,stderr@disk=2";
1495    if(kUseSysInfo>0)outputArchive = "log_archive.zip:stdout,stderr,syswatch.log@disk=2";
1496    if (listaods.Length()) {
1497       outputArchive += " ";
1498       outputArchive += listaods;
1499    }   
1500    if (listhists.Length()) {
1501       outputArchive += " ";
1502       outputArchive += listhists;
1503    }   
1504    plugin->SetOutputArchive(outputArchive);
1505 // Optionally set a name for the generated analysis macro (default MyAnalysis.C)
1506    plugin->SetAnalysisMacro(Form("%s.C", kTrainName.Data()));
1507 // Optionally set maximum number of input files/subjob (default 100, put 0 to ignore)
1508    plugin->SetSplitMaxInputFileNumber(kGridFilesPerJob);
1509 // Optionally set number of failed jobs that will trigger killing waiting sub-jobs.
1510 //   plugin->SetMaxInitFailed(5);
1511 // Optionally resubmit threshold.
1512 //   plugin->SetMasterResubmitThreshold(90);
1513 // Optionally set time to live (default 30000 sec)
1514    plugin->SetTTL(30000);
1515 // Optionally set input format (default xml-single)
1516    plugin->SetInputFormat("xml-single");
1517 // Optionally modify the name of the generated JDL (default analysis.jdl)
1518    plugin->SetJDLName(Form("%s.jdl", kTrainName.Data()));
1519 // Optionally modify the executable name (default analysis.sh)
1520    plugin->SetExecutable(Form("%s.sh", kTrainName.Data()));
1521 // Optionally modify job price (default 1)
1522    plugin->SetPrice(1);      
1523 // Optionally modify split mode (default 'se')    
1524    plugin->SetSplitMode("se");
1525    return plugin;
1526 }
1527
1528 //______________________________________________________________________________
1529 void WriteConfig()
1530 {
1531 // Write train configuration in a file. The file name has the format:
1532 // train_[trainName]_ddMonthyyyy_time.C
1533    if (kUseDate) {
1534       gSystem->Exec("date +%d%b%Y_%Hh%M > date.tmp");
1535       ifstream fdate("date.tmp");
1536       if (!fdate.is_open()) {
1537          ::Error("AnalysisTrainPWG4Jets.C::Export","Could not generate file name");
1538          return;
1539       }
1540       const char date[64];
1541       fdate.getline(date,64);
1542       fdate.close();
1543       gSystem->Exec("rm date.tmp");
1544       kTrainName = Form("train_%s_%s", kTrainName.Data(), date);
1545    } else {
1546       kTrainName = Form("train_%s", kTrainName.Data());
1547    }   
1548    TString cdir = gSystem->WorkingDirectory();
1549    gSystem->MakeDirectory(kTrainName);
1550    gSystem->ChangeDirectory(kTrainName);
1551    ofstream out;
1552    out.open(Form("%sConfig.C",kTrainName.Data()), ios::out); 
1553    if (out.bad()) {
1554       ::Error("AnalysisTrainPWG4Jets.C::Export", "Cannot open ConfigTrain.C for writing");
1555       return;
1556    }
1557    out << "{" << endl;
1558    out << "   kTrainName      = " << "\"" << kTrainName.Data() << "\";" << endl;
1559    out << "   kProofCluster   = " << "\"" << kProofCluster.Data() << "\";" << endl;
1560    out << "   kProofUseAFPAR        = " << kProofUseAFPAR << ";" << endl;
1561    if (kProofUseAFPAR) 
1562       out << "   kProofAFversion       = " << kProofAFversion.Data() << ";" << endl;
1563    out << "   kProofDataSet   = " << "\"" << kProofDataSet.Data() << "\";" << endl;
1564    out << "   kPluginUse       = " << kPluginUse << ";" << endl;
1565    out << "   kUsePAR          = " << kUsePAR << ";" << endl;
1566    out << "   kUseCPAR         = " << kUseCPAR << ";" << endl;
1567    out << "   kPluginRootVersion    = " << "\"" << kPluginRootVersion.Data() << "\";" << endl;
1568    out << "   kPluginAliRootVersion = " << "\"" << kPluginAliRootVersion.Data() << "\";" << endl;
1569    out << "   kGridDatadir   = " << "\"" << kGridDatadir.Data() << "\";" << endl;
1570    if (!kGridOutdir.Length()) kGridOutdir = Form("output_%s",kTrainName.Data());
1571    out << "   kGridOutdir    = " << "\"" << kGridOutdir.Data() << "\";" << endl;
1572    out << "   kGridMaxMergeFiles   = " << kGridMaxMergeFiles << ";" << endl;
1573    out << "   kGridMergeExclude    = " << "\"" << kGridMergeExclude.Data() << "\";" << endl;
1574    out << "   kGridRunsPerMaster  = " << kGridRunsPerMaster << ";" << endl;
1575    out << "   kGridFilesPerJob    = " << kGridFilesPerJob << ";" << endl;
1576    out << "   kGridRunRange[0]    = " << kGridRunRange[0] << ";" << endl;
1577    out << "   kGridRunRange[1]    = " << kGridRunRange[1] << ";" << endl;
1578    out << "   kUseDebug          = " << kUseDebug << ";" << endl;
1579    out << "   kUseMC           = " << kUseMC << ";" << endl;
1580    out << "   kUseESDTags         = " << kUseESDTags << ";" << endl;
1581    out << "   kUseKinefilter      = " << kUseKinefilter << ";" << endl;
1582    out << "   kUseTR           = " << kUseTR << ";" << endl;
1583    out << "   kUseAODTags      = " << kUseAODTags << ";" << endl;
1584    out << "   kSaveTrain       = " << "kFALSE;" << endl << endl;
1585    out << "   // Analysis modules" << endl;
1586    out << "   iAODanalysis    = " << iAODanalysis << ";" << endl;
1587    out << "   iAODhandler     = " << iAODhandler << ";" << endl;
1588    out << "   iESDfilter      = " << iESDfilter << ";" << endl;
1589    out << "   iJETAN          = " << iJETAN << ";" << endl;
1590    out << "// Configuration fot the wagons" << endl;
1591    out << "}" << endl;
1592    ::Info("AnalysisTrainPWG4Jets.C::WriteConfig", "Train configuration wrote to file %s", Form("config_%s.C", kTrainName.Data()));
1593    gSystem->ChangeDirectory(cdir);
1594 }   
1595
1596 //______________________________________________________________________________
1597 Bool_t LoadConfig(const char *filename)
1598 {
1599 // Read train configuration from file
1600    if (gSystem->AccessPathName(filename)) {
1601       ::Error("AnalysisTrainPWG4Jets.C::LoadConfig", "Config file name not found");
1602       return kFALSE;
1603    }   
1604    gROOT->ProcessLine(Form(".x %s", filename));
1605    ::Info("AnalysisTrainPWG4Jets.C::LoadConfig", "Train configuration loaded from file %s", filename);
1606    return kTRUE;
1607 }
1608
1609 Bool_t PatchJDL(){
1610   Printf(">>> Patching JDL");
1611   AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
1612   AliAnalysisAlien*    gridHandler = (AliAnalysisAlien*)mgr->GetGridHandler();
1613   TGridJDL *jdl = gridHandler->GetGridJDL();
1614   if(iJETAN)jdl->AddToPackages("fastjet","v2.4.0");
1615   gridHandler->WriteJDL(kFALSE);
1616   Printf("<<<  Patching JDL");
1617   return kTRUE;
1618 }
1619
1620 Bool_t PatchAnalysisMacro(){
1621     Printf(">>> Patching AnalysisMacro");
1622     gSystem->Exec(Form("mv %s.C %s.C_tmp",kTrainName.Data(),kTrainName.Data()));
1623
1624   ifstream in1; 
1625   in1.open(Form("%s.C_tmp", kTrainName.Data()));
1626   char cLine[250];
1627   TString st;
1628   while(in1.getline(cLine,250)){
1629     st += cLine;
1630     st += "\n";
1631   }
1632   Int_t index;
1633   index = st.Index("gSystem->Load(\"libPhysics\");");
1634   index += strlen("gSystem->Load(\"libPhysics\");");
1635   if(iJETAN&&kUsePAR){
1636     TObjArray *arr;
1637     TObjString *objstr;
1638     arr = anaLibs.Tokenize(" ");
1639     TIter next(arr);
1640     TString add = "";
1641     add += "\n\n // added by CKB \n";
1642     while ((objstr=(TObjString*)next())){
1643       if(objstr->GetString().Contains("PWG3"))continue;
1644       if(objstr->GetString().EndsWith(".so"))add += Form("gSystem->Load(\"%s\");\n",objstr->GetString().Data());
1645     }
1646     delete arr; 
1647     //    add += Form("AliLog::SetGlobalLogLevel(%d);\n",AliLog::GetGlobalLogLevel());
1648     add += "gSystem->AddIncludePath(\"./\") \n";
1649     if(gGrid&&kPluginAliRootVersion.Length()==0){
1650       add += "// Dirty hack for TRD reference data \n";
1651       add += "gSystem->Setenv(\"ALICE_ROOT\",\"";
1652       add += Form("alien://%s/rootfiles/",gGrid->GetHomeDirectory());
1653       add += "\"); \n";
1654     }
1655     add += "// BKC \n\n";
1656     st.Insert(index,add.Data());
1657   }
1658
1659   if(kUseDebug){
1660     st.Insert(index,"\n gROOT->ProcessLine(\".trace\"); // CKB \n");
1661   }
1662
1663   index = st.Index("gSystem->AddIncludePath");
1664   st.Insert(index,"// CKB ");
1665
1666   ofstream out;
1667   out.open(Form("%s.C", kTrainName.Data()));
1668   if (out.bad()) {
1669     return kFALSE;
1670   }
1671   out << st << endl;
1672   Printf("<<< Patching AnalysisMacro");
1673   return kTRUE;
1674
1675 }