PWG4/macros/AnalysisTrainPWG4.C

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