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 = kTRUE;  // switch of AOD filling for on the fly analysis
  35 Bool_t      kFilterAOD = kTRUE;
  36 Int_t       kSaveAOD = 8;        // Bit switch 1 = Full AOD 2 = Jet AOD , 4 = PartCorr, 8 = JCORRAN
  37 //== general input and output variables
  38
  39 Int_t       iAODanalysis       = 1;      // Analysis on input AOD's
  40 Int_t       iFilterAnalysis       = 0;      // Analysis on input AOD's
  41 Int_t       iAODhandler        = 1;      // Analysis produces an AOD or dAOD's
  42 Int_t       iCentralitySelection  = 0;      // Use the centrality
  43 Int_t       iESDfilter         = 0;      // ESD to AOD filter (barrel + muon tracks)
  44 Int_t       iPhysicsSelection  = 1;      // ESD to AOD filter (barrel + muon tracks)
  45 UInt_t      iPhysicsSelectionFlag = 1; // set by pyshics selection and passed to the task, kMB, kUserDefined etc
  46 Bool_t      useTender           = kFALSE; // use tender wagon
  47 Bool_t      kUseKinefilter     = kFALSE; // use Kinematics filter
  48 Bool_t      kUseMuonfilter     = kFALSE; // use Kinematics filter
  49 TString     kCommonOutputFileName = "PWG4_JetTasksOutput.root";
  50 TString     kCaloQAOutputFileName = "PWG4_CaloQAOutput.root";
  51
  52
  53 //== general process variables
  54
  55 // ### Other flags to steer the analysis
  56 //==============================================================================
  57 Bool_t      kSkipTerminate      = kTRUE; // Do not call Teminate
  58 Bool_t      kUseDate            = kFALSE; // use date in train name
  59 Bool_t      kUseDebug           = kTRUE; // activate debugging
  60 Int_t         kErrorIgnoreLevel = -1; // takes the errror print level from .rootrc
  61 // From TError.h:
  62 // const Int_t kUnset    =  -1;
  63 // const Int_t kPrint    =   0;
  64 // const Int_t kInfo     =   1000;
  65 // const Int_t kWarning  =   2000;
  66 // const Int_t kError    =   3000;
  67 // const Int_t kBreak    =   4000;
  68 // const Int_t kSysError =   5000;
  69 // const Int_t kFatal    =   6000;
  70 Int_t         kUseSysInfo         = 0; // activate debugging
  71 Long64_t    kNumberOfEvents     = 1234567890; // number of events to process from the chain
  72 Bool_t      kUseMC              = kTRUE;  // use MC info
  73 Bool_t      kIsMC               = kTRUE;  // is MC info, if false it overwrites Use(AOD)MC
  74 Bool_t      kUseAODMC           = kTRUE;  // use MC infA
  75 Bool_t      kUseESDTags         = kFALSE; // use ESD tags for selection
  76 Bool_t      kUseTR              = kFALSE;  // use track references
  77 Bool_t      kUseAODTags         = kFALSE;  // use AOD tags
  78 Bool_t      kSaveTrain          = kFALSE;  // save train configuration as:
  79 Bool_t      kIsPbPb             = kFALSE;  // Pb+Pb
  80
  81
  82 // ### Analysis modules to be included. Some may not be yet fully implemented.
  83 //==============================================================================
  84 Int_t       iJETAN             = 1;      // Jet analysis (PWG4) // 1 write standard 2 write non-standard jets, 3 wrtie both
  85 Int_t       iJETSUBTRACT        = 1;      // Jet background subtration
  86 TList       kJetListSpectrum;             // list of jets contains TObjString of possible jet finder names
  87 TExMap      kJetMapSpectrum;             // Maps the jet finder pairs to be used in the spectrum task second number negative no pair other wise (j1+1) + (1000 * (j2+1)) +10000 * (j3+1)
  88 TExMap      kJetBackMapSpectrum;             // Maps the jet finder pairs with the background branch used, just for countint of trackrefs
  89 Int_t       kJetMapOffset[3] = {10000,100,1};
  90 TString     kDefaultJetBranch     = "";      // is currently set when filled (iJETAN or clusters) or from config macro
  91 TString     kDefaultJetBackgroundBranch            = "";      // is currently set when filled (jet clsuters
  92 TString     kDefaultJetBackgroundBranchCut1        = "";      // is currently set when filled (jet clsuters
  93 TString     kDefaultJetBackgroundBranch_extra     = "";      // is currently set when filled (jet clsuters)
  94 TString     kJetSubtractBranches     = "";      // is currently set when filled (jet clsuters
  95 TString     kJetSubtractBranchesCut1     = "";      // is currently set when filled (jet clsuters
  96 TString     kJetSubtractBranches_extra     = "";      // is currently set when filled (jet clsuters
  97
  98 TString     kDefaultJetBranchMC     = "";      // is currently set when filled (iJETAN or clusters) or from config macro
  99 TString     kDefaultJetBackgroundBranchMC     = "";      // is currently set when filled (jet clsuters
 100 TString     kDefaultJetBranchMC2     = "";      // is currently set when filled (iJETAN or clusters) or from config macro
 101 TString     kDefaultJetBackgroundBranchMC2     = "";      // is currently set when filled (jet clsuters
 102 TString     kJetSubtractMask1 = "B0";
 103 TString     kJetSubtractMask2 = "B%d";
 104 Int_t       iDIJETAN           = 1;
 105 Int_t       iJETANLib          = 1;
 106 Int_t       iPWG1QASym         = 0;      // Eva's QA task compiled on the fly...
 107 Int_t       iPWG4FastEmbedding = 0;      // Generate non-standard AOD for embedding
 108 Int_t       iPWG4JetTasks      = 0;      // all jet tasks flag for lib laoding
 109 Int_t       iPWG4JetServices   = 0;      // jet spectrum analysis
 110 Int_t       iPWG4JetSpectrum   = 0;      // jet spectrum analysis
 111 Int_t       iPWG4JetResponse   = 0;      // jet response matrix
 112 Int_t       iPWG4JCORRAN       = 0;      // JCORRAN module
 113 Int_t       iPWG4UE            = 0;      // Underlying Event analysis
 114 Int_t       iPWG4LeadingUE     = 0;      // Underlying Event analysis
 115 Int_t       iPWG4CorrectionsUE = 0;      // Underlying Event analysis
 116 Int_t       iPWG4TmpSourceSara = 0;      // Underlying Event analysis not in svn
 117 Int_t       iPWG4Fragmentation = 1;      // Official Fragmentation
 118 Int_t       iPWG4JetChem       = 0;      // Jet chemistry
 119 Int_t       iPWG4PtQAMC        = 0;      // Marta's QA tasks
 120 Int_t       iPWG4PtTrackQA     = 0;      // Marta's QA tasks
 121 Int_t       iPWG4PtSpectra     = 0;      // Marta's QA tasks
 122 Int_t       iPWG4PtQATPC       = 0;      // Marta's QA tasks
 123 Int_t       iPWG4Cosmics     = 0;      // Marta's Cosmics Taks
 124 Int_t       iPWG4ThreeJets     = 0;      // Sona's thrust task
 125 Int_t       iPWG4QGSep     = 0;          // Sona's QG Separation task
 126 Int_t       iPWG4Minijet       = 0;      // Eva's Mini Jet Task cluster task
 127 Int_t       iPWG4KMeans        = 0;      // Andreas' KMeans task
 128 Int_t       iPWG4Cluster       = 0;      // CKB cluster task
 129 Int_t       iEMCUtilLibs       = 0;      // Flag to satisfy dependence on EMC utils
 130 Int_t       iPWG4PartCorrLibs  = 0;      // Gustavo's part corr analysis
 131 Int_t       iPWG4PartCorr      = 0;      // Gustavo's part corr analysis
 132 Int_t       iPWG4CaloQA        = 0;      // Gustavo's part corr analysis
 133 Int_t       iPWG4JetCorr       = 0;     // Paul's jet corr analysis
 134 Int_t       iPWG4Tagged        = 0;      // Gustavo's part corr analysis
 135 Int_t       iPWG4omega3pi      = 0;      // Omega to 3 pi analysis (PWG4)
 136 Int_t       iPWG4GammaConvLib     = 0;      // Gamma Conversio
 137 Int_t       iPWG4GammaConv     = 0;      // Gamma Conversio
 138 Int_t       iPWG4CaloConv     = 0;      // Gamma Conversio
 139 Int_t       kHighPtFilterMask  = 32;     // change depending on the used AOD Filter
 140 TString     kDeltaAODJetName   = "AliAOD.Jets.root";
 141 TString     kDeltaAODJetNameInput   = "";
 142 TString     kDeltaAODJCORRANName   = "AliAOD.JCORRAN.root";
 143 TString     kDeltaAODPartCorrName   = "AliAOD.PartCorr.root";
 144 TString     kFastEmbeddingAOD  = "emb/AliAOD.root";
 145 TString     kFastEmbAODList    = "";
 146
 147 //==============================================================================
 148 // ### PROOF Steering varibales
 149 //==============================================================================
 150 //== proof setup variables
 151 TString     kProofCluster      = "alicecaf.cern.ch";
 152 Bool_t      kProofUseAFPAR     = kFALSE;  // use AF special par file
 153 TString     kProofAFversion          = "AF-v4-17";
 154 //== proof input and output variables
 155 TString     kProofDataSet      = "/COMMON/COMMON/LHC09a4_run8100X#/esdTree";
 156 Bool_t      kProofSaveToAlien   = kFALSE; // save proof outputs in AliEn train_[trainName]_ddMonthyyyy_time.C
 157 TString     kProofOutdir       = "";
 158 Bool_t      kProofClearPackages = kFALSE;
 159 Int_t       kProofEvents = 10000;
 160 Int_t       kProofOffset = 0;
 161 //== proof process variables
 162
 163
 164 //==============================================================================
 165 // ### Grid plugin Steering varibiables
 166 //==============================================================================
 167 //== grid plugin setup variables
 168 Bool_t      kPluginUse         = kTRUE;   // do not change
 169 Bool_t      kPluginUseProductionMode  = kFALSE;   // use the plugin in production mode
 170 TString     kPluginRootVersion       = "v5-28-00c";  // *CHANGE ME IF MORE RECENT IN GRID*
 171 TString     kPluginAliRootVersion    = "v4-21-01a-AN";  // *CHANGE ME IF MORE RECENT IN GRID*
 172 Bool_t      kPluginMergeViaJDL       = kTRUE;  // merge via JDL
 173 Bool_t      kPluginFastReadOption   = kFALSE;  // use xrootd tweaks
 174 Bool_t      kPluginOverwriteMode    = kTRUE;  // overwrite existing collections
 175 Int_t       kPluginOutputToRunNumber = 1;     // write the output to subdirs named after run number
 176 // TString kPluginExecutableCommand = "root -b -q";
 177 TString     kPluginExecutableCommand = "source /Users/kleinb/setup_32bit_aliroot_trunk_clean_root_trunk.sh; alienroot -b -q ";
 178
 179 // == grid plugin input and output variables
 180 TString     kGridDatadir      = "/alice/sim/PDC_08b/LHC09a1/AOD/";
 181 Int_t         kGridMaxRunsFromList = 999999999;
 182 Int_t         kGridOffsetRunFromList = 0; // skip the first n runs from the list
 183 TString     kGridLocalRunList = "";
 184 TString     kGridOutdir       = ""; // AliEn output directory. If blank will become output_<kTrainName>
 185 TString     kGridDataSet      = ""; // sub working directory not to confuse different run xmls
 186 TString     kGridExtraAliendirLevel = ""; // sub working directory not to confuse different run xmls
 187 Int_t         kGridRunRange[2]       =  {0, -1}; // Set the run range
 188 TString     kGridRunPattern        = "%03d"; // important for leading zeroes!!
 189 TString     kGridPassPattern       = "";
 190 TString     kGridExtraFiles        = ""; // files that will be added to the input list in the JDL...
 191 Int_t         kGridMaxMergeFiles      = 25; // Number of files merged in a chunk grid run range
 192 TString     kGridMergeExclude       = "AliAOD.root"; // Files that should not be merged
 193 TString     kGridOutputStorages      = "disk=2"; // Make replicas on the storages
 194 // == grid process variables
 195 Int_t       kGridRunsPerMaster     = 100; // Number of runs per master job
 196 Int_t       kGridFilesPerJob       = 100; // Maximum number of files per job (gives size of AOD)
 197
 198 //==============================================================================
 199 // ### Local Steering variables
 200 //==============================================================================
 201 //== local setup variables
 202 //== local input and output variables
 203 TString     kLocalXMLDataset   = ""; // Change local xml dataset for local interactive analysis
 204 TString     kLocalDataList   = "local_deltaaod.txt"; // Change local xml dataset for local interactive analysis
 205 // == local process variables
 206
 207 TString kPluginMode = "";
 208 TString kAnalysisMode = "";
 209
 210
 211 // Temporaries.
 212 TString anaPars = "";
 213 TString anaLibs = "";
 214 TString anaLibsExtra = "";
 215 TString anaSources = "";
 216 // Function signatures
 217 class AliAnalysisAlien;
 218 class AliAnalysisManager;
 219
 220 //______________________________________________________________________________
 221 void AnalysisTrainPWG4Jets(const char *analysis_mode="local",
 222                            const char *plugin_mode="",
 223                            const char *config_file="",Int_t iOffset = 0,Int_t iTotal = 0)
 224 {
 225 // Main analysis train macro. If a configuration file is provided, all parameters
 226 // are taken from there but may be altered by CheckModuleFlags.
 227
 228   // these flag may be needed by the config file
 229   kPluginMode   = plugin_mode;
 230   kAnalysisMode = analysis_mode;
 231
 232   if (strlen(config_file) && !LoadConfig(config_file)) return;
 233   if(iTotal>0)kGridMaxRunsFromList = iTotal; // overwrites the settings from config file
 234   if(iOffset)kGridOffsetRunFromList = iOffset;
 235   if(iOffset)kProofOffset = iOffset;
 236
 237
 238    TString smode(analysis_mode);
 239    smode.ToUpper();
 240    if (kSaveTrain)WriteConfig();
 241    // Check compatibility of selected modules
 242    CheckModuleFlags(smode);
 243    //     gROOT->ProcessLine(".trace");
 244
 245    printf("==================================================================\n");
 246    printf("===========    RUNNING ANALYSIS TRAIN %s IN %s MODE   ==========\n", kTrainName.Data(),smode.Data());
 247    printf("==================================================================\n");
 248                               printf("=  Configuring analysis train for:                               =\n");
 249    if (iAODanalysis) printf("=  AOD analysis                                                  =\n");
 250    else                     printf("=  ESD analysis                                                  =\n");
 251    if (iPhysicsSelection)   printf("=  Physics selection                                                =\n");
 252    if(iCentralitySelection)printf("=  Centrality selection                                                =\n");
 253    if (useTender)   printf("=  Using tender                                                =\n");
 254    if (iESDfilter)   printf("=  ESD filter                                                    =\n");
 255    if (iJETAN)       printf("=  Jet analysis                                                  =\n");
 256    printf("==================================================================\n");
 257
 258    char *printMask = ":: %20s  %10d\n";
 259    printf(printMask,"Fill AOD",(UInt_t)kFillAOD);
 260    printf(printMask,"Save AOD", (UInt_t)kSaveAOD);
 261    printf(printMask,"MC truth", (UInt_t)kUseMC);
 262    printf(printMask,"KINE filter", (UInt_t)kUseKinefilter);
 263    printf(printMask,"track refs", (UInt_t)kUseTR);
 264    printf(printMask,"tags", (UInt_t)kUseESDTags);
 265    printf(printMask,"AOD tags", (UInt_t)kUseAODTags);
 266    printf(printMask,"debugging", (UInt_t)kUseDebug);
 267    printf(printMask,"PAR files", (UInt_t)kUsePAR);
 268    printf(printMask,"AliEn plugin", (UInt_t)kPluginUse);
 269    printf(printMask,"JETAN subtract", (UInt_t)iJETSUBTRACT);
 270    printf(printMask,"PWG1 QA sym", iPWG1QASym);
 271    printf(printMask,"PWG4 Source Sara",iPWG4TmpSourceSara);
 272    printf(printMask,"PWG4 Fragmentation",iPWG4Fragmentation);
 273    printf(printMask,"PWG4 Jet Chem",iPWG4JetChem);
 274    printf(printMask,"PWG4 Jet tasks",iPWG4JetTasks);
 275    printf(printMask,"PWG4 Jet Services",iPWG4JetServices);
 276    printf(printMask,"PWG4 Jet Spectrum",iPWG4JetSpectrum);
 277    printf(printMask,"PWG4 JCORRAN",iPWG4JCORRAN);
 278    printf(printMask,"PWG4 UE",iPWG4UE);
 279    printf(printMask,"PWG4 Leading UE",iPWG4LeadingUE);
 280    printf(printMask,"PWG4 Corrections UE",iPWG4CorrectionsUE);
 281    printf(printMask,"PWG4 Pt QA MC",iPWG4PtQAMC);
 282    printf(printMask,"PWG4 Pt QA track",iPWG4PtTrackQA);
 283    printf(printMask,"PWG4 Pt Spectra",iPWG4PtSpectra);
 284    printf(printMask,"PWG4 Pt QA TPC",iPWG4PtQATPC);
 285    printf(printMask,"PWG4 Cosmics",iPWG4Cosmics);
 286    printf(printMask,"PWG4 Three Jets",iPWG4ThreeJets);
 287    printf(printMask,"PWG4 QGSep",iPWG4QGSep);
 288    printf(printMask,"PWG4 Minijet",iPWG4Minijet);
 289    printf(printMask,"PWG4 KMeans",iPWG4KMeans);
 290    printf(printMask,"PWG4 Cluster",iPWG4Cluster);
 291    printf(printMask,"PWG4 Part Corr",iPWG4PartCorr);
 292    printf(printMask,"PWG4 Calo QA",iPWG4CaloQA);
 293    printf(printMask,"PWG4 Jet Corr",iPWG4JetCorr);
 294    printf(printMask,"PWG4 JCORRAN",iPWG4JCORRAN);
 295    printf(printMask,"PWG4 Tagged",iPWG4Tagged);
 296    printf(printMask,"PWG4 omega to 3 pi ",iPWG4omega3pi);
 297    printf(printMask,"PWG4 Gamma Conv",iPWG4GammaConv);
 298    printf(printMask,"PWG4 Calo Conv",iPWG4CaloConv);
 299    printf(printMask,"HighPt FilterMask",kHighPtFilterMask);
 300
 301    //==========================================================================
 302    // Connect to back-end system
 303    if (!Connect(smode)) {
 304       ::Error("AnalysisTrain", "Could not connect to %s back-end", analysis_mode);
 305       return;
 306    }
 307
 308    // Load common libraries and set include path
 309    if (!LoadCommonLibraries(smode)) {
 310       ::Error("AnalysisTrain", "Could not load common libraries");
 311       return;
 312    }
 313
 314
 315
 316    // Make the analysis manager and connect event handlers
 317    AliAnalysisManager *mgr  = new AliAnalysisManager("PWG4Train", "pwg4 mini train");
 318    if (kCommonOutputFileName.Length()>0)mgr->SetCommonFileName(kCommonOutputFileName.Data());
 319    if (kProofSaveToAlien) mgr->SetSpecialOutputLocation(kProofOutdir);
 320    mgr->SetNSysInfo(0);
 321    if (!strcmp(plugin_mode, "test")) mgr->SetNSysInfo(1);
 322    if (kUseSysInfo)mgr->SetNSysInfo(kUseSysInfo);
 323    mgr->SetSkipTerminate(kSkipTerminate);
 324
 325    // Load analysis specific libraries
 326    if (!LoadAnalysisLibraries(smode)) {
 327       ::Error("AnalysisTrain", "Could not load analysis libraries");
 328      return;
 329    }
 330
 331    // Create input handler (input container created automatically)
 332    if (iAODanalysis) {
 333    // AOD input handler
 334       AliAODInputHandler *aodH = new AliAODInputHandler();
 335       mgr->SetInputEventHandler(aodH);
 336       if (kDeltaAODJetNameInput.Length()){
 337         Printf("Adding Friend %s",kDeltaAODJetNameInput.Data());
 338         aodH->AddFriend(kDeltaAODJetNameInput.Data());
 339       }
 340       //      if (iPWG4PartCorr) aodH->AddFriend(Form("deltas/%s"kDeltaAODJetName.Data()));
 341    } else {
 342    // ESD input handler
 343       AliESDInputHandler *esdHandler = new AliESDInputHandler();
 344       if (kUseESDTags) esdHandler->SetReadTags();
 345       esdHandler->SetReadFriends(kFALSE);
 346       mgr->SetInputEventHandler(esdHandler);
 347       //      if(iPWG4PtQATPC&& !kTrainName.Contains("pass5"))esdHandler->SetActiveBranches("ESDfriend");
 348
 349    }
 350
 351    // Monte Carlo handler
 352    if (kUseMC && !iAODanalysis) {
 353       AliMCEventHandler* mcHandler = new AliMCEventHandler();
 354       mgr->SetMCtruthEventHandler(mcHandler);
 355       mcHandler->SetReadTR(kUseTR);
 356    }
 357    // AOD output container, created automatically when setting an AOD handler
 358    if (iAODhandler) {
 359       // AOD output handler
 360       AliAODHandler* aodHandler   = new AliAODHandler();
 361       aodHandler->SetOutputFileName("AliAOD.root");
 362       aodHandler->SetFillAODforRun(kFillAOD);
 363       //
 364       mgr->SetOutputEventHandler(aodHandler);
 365       AliAnalysisDataContainer * cout_aod = mgr->GetCommonOutputContainer();
 366       cout_aod->SetSpecialOutput();
 367    }
 368    // Debugging if needed
 369
 370    if (kUseDebug){
 371      mgr->SetDebugLevel(3);
 372    }
 373    if(kUseSysInfo>0){
 374      mgr->RegisterExtraFile("syswatch.root");
 375      if(kGridMergeExclude.Length())kGridMergeExclude += " ";
 376      kGridMergeExclude += "syswatch.root";
 377    }
 378    else{
 379      AliLog::SetGlobalLogLevel(AliLog::kError);
 380    }
 381
 382
 383    //==========================================================================
 384    // Create the chain. In this example it is created only from ALIEN files but
 385    // can be done to work in batch or grid mode as well.
 386    TChain *chain = CreateChain(smode, plugin_mode);
 387
 388    //==========================================================================
 389    // Load the tasks configuration macros for all wagons. These files are supposed now to be
 390    // in the current workdir, but in AliEn they will be in the file catalog,
 391    // mapped from AliRoot and pecified in the jdl input list.
 392
 393    // For now connection to top input container and common AOD output container
 394    // is done in this macro, but in future these containers will be connected
 395    // from each task configuration macro.
 396
 397    //
 398    // Tender and supplies. Needs to be called for every event.
 399    //
 400
 401    if (useTender) {
 402       gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/TenderSupplies/AddTaskTender.C");
 403       AliAnalysisTaskSE *tender = AddTaskTender(kTRUE);
 404       //      tender->SelectCollisionCandidates();
 405       tender->SetDebugLevel(2);
 406    }
 407
 408
 409    Float_t fTrackEtaWindow = 0.9;
 410    Float_t fJetEtaWindow   = 0.5;
 411
 412    /*
 413    if(kIsPbPb){// for pass1
 414      Float_t fTrackEtaWindow = 0.8;
 415      Float_t fJetEtaWindow   = 0.4;
 416    }
 417    */
 418
 419
 420    if(iPhysicsSelection && !iAODanalysis){
 421      gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
 422      Int_t iTriggerC = 0;
 423      Bool_t rejectBkg = true;
 424      if(kIsPbPb){
 425        iTriggerHIC = 2;
 426        rejectBkg = false; // for the moment...
 427      }
 428      AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(kIsMC,rejectBkg);
 429
 430      mgr->RegisterExtraFile("EventStat_temp.root");
 431      mgr->AddStatisticsTask();
 432    }
 433    else{
 434      iPhysicsSelectionFlag = AliVEvent::kMB;
 435    }
 436
 437    if(iCentralitySelection){
 438
 439      // has to run before AOD filter
 440      gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskCentrality.C");
 441      //     const char* file1="$ALICE_ROOT/ANALYSIS/macros/AliCentralityBy1D_137161.root";
 442      //     const char* file2="$ALICE_ROOT/ANALYSIS/macros/AliCentralityByFunction_137161.root";
 443      AliCentralitySelectionTask *taskC = AddTaskCentrality();
 444       if (!taskC) ::Warning("AnalysisTrainPWG4Jets", "AliCentralitySelectionTask cannot run for this train conditions - EXCLUDED");
 445    }
 446
 447    if (iESDfilter && !iAODanalysis) {
 448       //  ESD filter task configuration.
 449       gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskESDFilterPWG4Train.C");
 450       AliAnalysisTaskESDfilter *taskesdfilter = AddTaskESDFilter(kUseKinefilter,kUseMuonfilter);
 451       taskesdfilter->SetEnableFillAOD(!kFilterAOD);
 452       taskesdfilter->DisableV0s();
 453       taskesdfilter->DisableCascades();
 454       taskesdfilter->DisableKinks();
 455       taskesdfilter->DisablePmdClusters();
 456       taskesdfilter->DisableCaloClusters();
 457       taskesdfilter->DisableCells();
 458
 459       if(kIsMC){
 460         mgr->RegisterExtraFile("pyxsec_hists.root");
 461         if(kGridMergeExclude.Length())kGridMergeExclude += " ";
 462         kGridMergeExclude += "pyxsec_hists.root";
 463
 464       }
 465    }
 466
 467    // AOD tags
 468    if (kUseAODTags) {
 469       AliAnalysisTaskTagCreator* tagTask = new AliAnalysisTaskTagCreator("AOD Tag Creator");
 470       mgr->AddTask(tagTask);
 471       AliAnalysisDataContainer *coutTags = mgr->CreateContainer("cTag",  TTree::Class(),
 472                                            AliAnalysisManager::kOutputContainer, "AOD.tag.root");
 473       mgr->ConnectInput (tagTask, 0, mgr->GetCommonInputContainer());
 474       mgr->ConnectOutput(tagTask, 1, coutTags);
 475    }
 476
 477    if (iPWG4FastEmbedding) {
 478      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskFastEmbedding.C");
 479      AliAnalysisTaskFastEmbedding *taskEmbedding = 0;
 480      if(kFastEmbAODList.Length()) taskEmbedding = AddTaskFastEmbedding(kFastEmbAODList, 1);
 481      else                         taskEmbedding = AddTaskFastEmbedding(kFastEmbeddingAOD, 0);
 482      taskEmbedding->SetJetBranch("jetsAOD_UA104_B0_Filter00256_Cut01000");
 483      // taskEmbedding->SetEvtSelecMode(AliAnalysisTaskFastEmbedding::kEventsAll);
 484      // taskEmbedding->SetDebugLevel(10);
 485    }
 486
 487     // Jet analysis
 488    if (iJETAN) {
 489       gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJets.C");
 490       AliAnalysisTaskJets *taskjets = 0;
 491       if(iJETAN&1){
 492         /*
 493         taskjets = AddTaskJets(kHighPtFilterMask);
 494         taskjets->SetName("StandardJets");
 495         taskjets->SetNonStdBranch("");
 496         */
 497       }
 498       if(iJETAN&2){
 499         // Set only few jet finders  backgroudn subtraction w an wo
 500
 501         taskjets = AddTaskJets("AOD","UA1",0.4,kHighPtFilterMask,1.,0); // no background subtraction
 502         if(kDeltaAODJetName.Length()>0)taskjets->SetNonStdOutputFile(kDeltaAODJetName.Data());
 503         TString cTmp("");
 504         cTmp = taskjets->GetNonStdBranch();
 505         if(cTmp.Length())kJetListSpectrum.Add(new TObjString(cTmp.Data()));
 506
 507         taskjets = AddTaskJets("AOD","UA1",0.4,kHighPtFilterMask,2.,0); // no background subtraction
 508         if(kDeltaAODJetName.Length()>0)taskjets->SetNonStdOutputFile(kDeltaAODJetName.Data());
 509         TString cTmp("");
 510         cTmp = taskjets->GetNonStdBranch();
 511         if(cTmp.Length())kJetListSpectrum.Add(new TObjString(cTmp.Data()));
 512
 513
 514         // STANDARD UA jet finders pT cut 1 GeV background mode 2 R = 0.4
 515         if(kIsPbPb){
 516           taskjets = AddTaskJets("AOD","UA1",0.4,kHighPtFilterMask,1.,2); // background subtraction
 517           if(kDeltaAODJetName.Length()>0)taskjets->SetNonStdOutputFile(kDeltaAODJetName.Data());
 518           cTmp = taskjets->GetNonStdBranch();
 519           if(cTmp.Length())kJetListSpectrum.Add(new TObjString(cTmp.Data()));
 520           taskjets = AddTaskJets("AOD","UA1",0.4,kHighPtFilterMask,2.,2); // background subtraction
 521           if(kDeltaAODJetName.Length()>0)taskjets->SetNonStdOutputFile(kDeltaAODJetName.Data());
 522           cTmp = taskjets->GetNonStdBranch();
 523           if(cTmp.Length())kJetListSpectrum.Add(new TObjString(cTmp.Data()));
 524         }
 525
 526
 527
 528         // SICONE
 529         /*
 530         taskjets = AddTaskJets("AOD","SISCONE",0.4,kHighPtFilterMask,0.15,0); //no background subtraction to be done later....
 531         if(kDeltaAODJetName.Length()>0)taskjets->SetNonStdOutputFile(kDeltaAODJetName.Data());
 532         cTmp = taskjets->GetNonStdBranch();
 533         if(cTmp.Length()>0)kJetSubtractBranches += Form("%s ",cTmp.Data());
 534         if(cTmp.Length())kJetListSpectrum.Add(new TObjString(cTmp.Data()));
 535         */
 536         if(kUseAODMC){
 537           // STANDARD UA jet finders pT cut 1 GeV background mode 2 R = 0.4
 538           if(kIsPbPb){
 539             taskjets = AddTaskJets("AODMC","UA1",0.4,kHighPtFilterMask,1.,2); // background subtraction
 540             cTmp = taskjets->GetNonStdBranch();
 541             if(cTmp.Length())kJetListSpectrum.Add(new TObjString(cTmp.Data()));
 542             taskjets = AddTaskJets("AODMC2","UA1",0.4,kHighPtFilterMask,1.,2); // background subtraction
 543             cTmp = taskjets->GetNonStdBranch();
 544             if(cTmp.Length())kJetListSpectrum.Add(new TObjString(cTmp.Data()));
 545           }
 546           else{
 547             taskjets = AddTaskJets("AODMC","UA1",0.4,kHighPtFilterMask,1.,0); // no background subtraction
 548             cTmp = taskjets->GetNonStdBranch();
 549             if(cTmp.Length())kJetListSpectrum.Add(new TObjString(cTmp.Data()));
 550             taskjets = AddTaskJets("AODMC2","UA1",0.4,kHighPtFilterMask,1.,0); // no background subtraction
 551             cTmp = taskjets->GetNonStdBranch();
 552             if(cTmp.Length())kJetListSpectrum.Add(new TObjString(cTmp.Data()));
 553           }
 554         }
 555         if(kDeltaAODJetName.Length()>0)mgr->RegisterExtraFile(kDeltaAODJetName.Data());
 556       }
 557       if (!taskjets) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskJets cannot run for this train conditions - EXCLUDED");
 558    }
 559
 560
 561    if (iPWG4FastEmbedding && iJETAN) {
 562      AliAnalysisTaskJets *taskEmbJets = AddTaskJets("AODextra", "FASTJET", 0.4, kHighPtFilterMask);
 563      taskEmbJets->ReadAODFromOutput();
 564      kJetSubtractBranches_extra += Form("%s ", taskEmbJets->GetNonStdBranch());
 565
 566      taskEmbJets = AddTaskJets("AODextraonly", "FASTJET", 0.4, kHighPtFilterMask);
 567      taskEmbJets->ReadAODFromOutput();
 568
 569      taskEmbJets = AddTaskJets("AODextra", "UA1", 0.4, kHighPtFilterMask,1.,0);
 570      taskEmbJets->ReadAODFromOutput();
 571      taskEmbJets = AddTaskJets("AODextraonly", "UA1", 0.4, kHighPtFilterMask,1.,0);
 572      taskEmbJets->ReadAODFromOutput();
 573      taskEmbJets = AddTaskJets("AODextra", "UA1", 0.4, kHighPtFilterMask,1.,2);
 574      taskEmbJets->ReadAODFromOutput();
 575    }
 576
 577    if(iPWG4Cluster){
 578      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJetCluster.C");
 579      AliAnalysisTaskJetCluster *taskCl = 0;
 580      Float_t fCenUp = 0;
 581      Float_t fCenLo = 0;
 582      if(kIsPbPb&&!kIsMC){
 583        fCenLo = 0;
 584        fCenUp = 80;
 585      }
 586      if(iPWG4Cluster&1){
 587
 588        if(kIsPbPb){
 589          taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.4,0,1, kDeltaAODJetName.Data(),0.15,fTrackEtaWindow,0); // this one is for the background and random jets, random cones with no skip
 590          taskCl->SetBackgroundCalc(kTRUE);
 591          taskCl->SetNRandomCones(1);
 592          taskCl->SetEventSelection(kTRUE); // saves some computing time, not all vertices are processed
 593          //      taskCl->SetDebugLevel(11);
 594          taskCl->SetCentralityCut(fCenLo,fCenUp);
 595          taskCl->SetGhostEtamax(fTrackEtaWindow);
 596          kDefaultJetBackgroundBranch = Form("%s_%s",AliAODJetEventBackground::StdBranchName(),taskCl->GetJetOutputBranch());
 597          kJetListSpectrum.Add(new TObjString(taskCl->GetJetOutputBranch()));
 598          kJetListSpectrum.Add(new TObjString(Form("%sRandomConeSkip%02d",taskCl->GetJetOutputBranch(),0)));
 599          kJetListSpectrum.Add(new TObjString(Form("%sRandomCone_random",taskCl->GetJetOutputBranch())));
 600          kJetSubtractBranches += Form("%s%s ",taskCl->GetJetOutputBranch(),"RandomConeSkip00");
 601          kJetSubtractBranches += Form("%s%s ",taskCl->GetJetOutputBranch(),"RandomCone_random");
 602
 603          taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.4,0,1, kDeltaAODJetName.Data(),2.0,fTrackEtaWindow,0); // this one is for the background and random jets, random cones with no skip
 604          taskCl->SetEventSelection(kTRUE); // saves some computing time, not all vertices are processed
 605          taskCl->SetNRandomCones(1);
 606          taskCl->SetBackgroundCalc(kTRUE);
 607          taskCl->SetCentralityCut(fCenLo,fCenUp);
 608          taskCl->SetGhostEtamax(fTrackEtaWindow);
 609          if(iAODanalysis==2)taskCl->SetAODTrackInput(kTRUE);
 610          kDefaultJetBackgroundBranchCut1 = Form("%s_%s",AliAODJetEventBackground::StdBranchName(),taskCl->GetJetOutputBranch());
 611          kJetSubtractBranchesCut1 += Form("%s%s ",taskCl->GetJetOutputBranch(),"RandomConeSkip00");
 612          kJetSubtractBranchesCut1 += Form("%s%s ",taskCl->GetJetOutputBranch(),"RandomCone_random");
 613          kJetListSpectrum.Add(new TObjString(taskCl->GetJetOutputBranch()));
 614          kJetListSpectrum.Add(new TObjString(Form("%sRandomConeSkip%02d",taskCl->GetJetOutputBranch(),0)));
 615          kJetListSpectrum.Add(new TObjString(Form("%sRandomCone_random",taskCl->GetJetOutputBranch())));
 616
 617          if (iPWG4FastEmbedding) {
 618            AliAnalysisTaskJetCluster *taskClEmb = 0;
 619            taskClEmb = AddTaskJetCluster("AODextra","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.4,0,1, kDeltaAODJetName.Data(),0.15,fTrackEtaWindow); // this one is for the background and random jets
 620          taskCl->SetEventSelection(kTRUE); // saves some computing time, not all vertices are processed
 621            taskClEmb->SetBackgroundCalc(kTRUE);
 622            taskClEmb->SetCentralityCut(fCenLo,fCenUp);
 623            taskClEmb->SetGhostEtamax(fTrackEtaWindow);
 624            if(iAODanalysis==2)taskClEmb->SetAODTrackInput(kTRUE);
 625            kDefaultJetBackgroundBranch_extra = Form("%s_%s",AliAODJetEventBackground::StdBranchName(),taskClEmb->GetJetOutputBranch());
 626
 627            taskClEmb = AddTaskJetCluster("AODextraonly","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.4,0,1, kDeltaAODJetName.Data(),0.15,fTrackEtaWindow); // this one is for the background and random jets
 628            taskCl->SetEventSelection(kTRUE); // saves some computing time, not all vertices are processed
 629            taskClEmb->SetBackgroundCalc(kFALSE);
 630            taskClEmb->SetCentralityCut(fCenLo,fCenUp);
 631            taskClEmb->SetGhostEtamax(fTrackEtaWindow);
 632            if(iAODanalysis==2)taskClEmb->SetAODTrackInput(kTRUE);
 633
 634            taskClEmb = AddTaskJetCluster("AODextra","",kHighPtFilterMask,iPhysicsSelectionFlag,"ANTIKT",0.4,0,1,kDeltaAODJetName.Data(),0.15,fTrackEtaWindow);
 635          taskCl->SetEventSelection(kTRUE); // saves some computing time, not all vertices are processed
 636            taskClEmb->SetCentralityCut(fCenLo,fCenUp);
 637            taskClEmb->SetBackgroundBranch(kDefaultJetBackgroundBranch_extra.Data());
 638            kJetSubtractBranches_extra += Form("%s ",taskClEmb->GetJetOutputBranch());
 639            if(iAODanalysis==2)taskClEmb->SetAODTrackInput(kTRUE);
 640
 641            taskClEmb = AddTaskJetCluster("AODextraonly","",kHighPtFilterMask,iPhysicsSelectionFlag,"ANTIKT",0.4,0,1,kDeltaAODJetName.Data(),0.15,fTrackEtaWindow);
 642            taskClEmb->SetCentralityCut(fCenLo,fCenUp);
 643            if(iAODanalysis==2)taskClEmb->SetAODTrackInput(kTRUE);
 644          }
 645
 646          taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.2,0,1, kDeltaAODJetName.Data(),0.15); // this one is for the background and random jets
 647          taskCl->SetEventSelection(kTRUE); // saves some computing time, not all vertices are processed
 648          taskCl->SetBackgroundCalc(kTRUE);
 649          taskCl->SetCentralityCut(fCenLo,fCenUp);
 650          taskCl->SetGhostEtamax(fTrackEtaWindow);
 651          kJetListSpectrum.Add(new TObjString(taskCl->GetJetOutputBranch()));
 652          if(iAODanalysis==2)taskCl->SetAODTrackInput(kTRUE);
 653        }
 654        else{
 655          taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.6,0,1,kDeltaAODJetName.Data(),0.15); // this one is for the background jets
 656          taskCl->SetEventSelection(kTRUE); // saves some computing time, not all vertices are processed
 657          taskCl->SetBackgroundCalc(kTRUE);
 658          kDefaultJetBackgroundBranch = Form("%s_%s",AliAODJetEventBackground::StdBranchName(),taskCl->GetJetOutputBranch());
 659          taskCl->SetGhostEtamax(fTrackEtaWindow);
 660          if(iAODanalysis==2)taskCl->SetAODTrackInput(kTRUE);
 661          kJetListSpectrum.Add(new TObjString(taskCl->GetJetOutputBranch()));
 662
 663          taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.4,0,1,kDeltaAODJetName.Data(),0.15);
 664          taskCl->SetEventSelection(kTRUE); // saves some computing time, not all vertices are processed
 665          taskCl->SetBackgroundCalc(kTRUE);
 666          taskCl->SetGhostEtamax(fTrackEtaWindow);
 667          if(iAODanalysis==2)taskCl->SetAODTrackInput(kTRUE);
 668          kJetListSpectrum.Add(new TObjString(taskCl->GetJetOutputBranch()));
 669        }
 670
 671        taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"ANTIKT",0.4,2,1,kDeltaAODJetName.Data(),0.15);
 672        taskCl->SetEventSelection(kTRUE); // saves some computing time, not all vertices are processed
 673        taskCl->SetCentralityCut(fCenLo,fCenUp);
 674        if(kIsPbPb)taskCl->SetBackgroundBranch(kDefaultJetBackgroundBranch.Data());
 675
 676
 677        if(iFilterAnalysis==2){
 678          if(kIsPbPb)taskCl->SetJetTriggerPtCut(40);
 679          else taskCl->SetJetTriggerPtCut(20.);
 680        }
 681
 682
 683        //       taskCl->SetDebugLevel(3);
 684
 685        taskCl->SetNRandomCones(1);
 686        if(iAODanalysis==2)taskCl->SetAODTrackInput(kTRUE);
 687        kDefaultJetBranch = taskCl->GetJetOutputBranch();
 688        kJetSubtractBranches += Form("%s ",taskCl->GetJetOutputBranch());
 689        kJetSubtractBranches += Form("%s%s ",taskCl->GetJetOutputBranch(),"RandomConeSkip02");
 690        kJetSubtractBranches += Form("%s%s ",taskCl->GetJetOutputBranch(),"RandomCone_random");
 691        kJetListSpectrum.Add(new TObjString(taskCl->GetJetOutputBranch()));
 692        kJetListSpectrum.Add(new TObjString(Form("%sRandomConeSkip%02d",taskCl->GetJetOutputBranch(),2)));
 693        kJetListSpectrum.Add(new TObjString(Form("%sRandomCone_random",taskCl->GetJetOutputBranch())));
 694
 695        taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"ANTIKT",0.4,2,1,kDeltaAODJetName.Data(),2.0);
 696        taskCl->SetEventSelection(kTRUE); // saves some computing time, not all vertices are processed
 697        taskCl->SetCentralityCut(fCenLo,fCenUp);
 698        if(iAODanalysis==2)taskCl->SetAODTrackInput(kTRUE);
 699        if(kIsPbPb)taskCl->SetBackgroundBranch(kDefaultJetBackgroundBranchCut1.Data());
 700        kJetSubtractBranchesCut1 += Form("%s ",taskCl->GetJetOutputBranch());
 701        kJetListSpectrum.Add(new TObjString(taskCl->GetJetOutputBranch()));
 702
 703        // tmp track qa...
 704        taskCl = AddTaskJetCluster("AOD","",1<<8,iPhysicsSelectionFlag,"ANTIKT",0.4,2,1,kDeltaAODJetName.Data(),2.0);
 705        taskCl->SetEventSelection(kTRUE); // saves some computing time, not all vertices are processed
 706        taskCl->SetCentralityCut(fCenLo,fCenUp);
 707        taskCl->SetFilterMask(1<<4|1<<8,1);
 708
 709        taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelectionFlag,"ANTIKT",0.2,0,1,kDeltaAODJetName.Data(),0.15);
 710        taskCl->SetCentralityCut(fCenLo,fCenUp);
 711        taskCl->SetEventSelection(kTRUE); // saves some computing time, not all vertices are processed
 712        if(iAODanalysis==2)taskCl->SetAODTrackInput(kTRUE);
 713        if(kIsPbPb)taskCl->SetBackgroundBranch(kDefaultJetBackgroundBranch.Data());
 714        kJetSubtractBranches += Form("%s ",taskCl->GetJetOutputBranch());
 715        kJetListSpectrum.Add(new TObjString(taskCl->GetJetOutputBranch()));
 716
 717        if(kUseAODMC){
 718          if(kIsPbPb){
 719            taskCl = AddTaskJetCluster("AODMC","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.4,0,1, kDeltaAODJetName.Data(),0.15,fTrackEtaWindow); // this one is for the background and random jets
 720            taskCl->SetEventSelection(kTRUE); // saves some computing time, not all vertices are processed
 721            taskCl->SetBackgroundCalc(kTRUE);
 722            taskCl->SetGhostEtamax(0.9);
 723            kDefaultJetBackgroundBranchMC = Form("%s_%s",AliAODJetEventBackground::StdBranchName(),taskCl->GetJetOutputBranch());
 724            if(iAODanalysis==2)taskCl->SetAODTrackInput(kTRUE);
 725          kJetListSpectrum.Add(new TObjString(taskCl->GetJetOutputBranch()));
 726
 727            taskCl = AddTaskJetCluster("AODMC2","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.4,0,1, kDeltaAODJetName.Data(),0.15); // this one is for the background and random jets
 728          taskCl->SetEventSelection(kTRUE); // saves some computing time, not all vertices are processed
 729            taskCl->SetBackgroundCalc(kTRUE);
 730            taskCl->SetGhostEtamax(fTrackEtaWindow);
 731            kDefaultJetBackgroundBranchMC2 = Form("%s_%s",AliAODJetEventBackground::StdBranchName(),taskCl->GetJetOutputBranch(),fTrackEtaWindow);
 732            if(iAODanalysis==2)taskCl->SetAODTrackInput(kTRUE);
 733            kJetListSpectrum.Add(new TObjString(taskCl->GetJetOutputBranch()));
 734          }
 735          else{
 736            taskCl = AddTaskJetCluster("AODMC","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.6,0,1, kDeltaAODJetName.Data(),0.15,fTrackEtaWindow); // this one is for the background and random jets
 737            taskCl->SetEventSelection(kTRUE); // saves some computing time, not all vertices are processed
 738            taskCl->SetBackgroundCalc(kTRUE);
 739            taskCl->SetGhostEtamax(fTrackEtaWindow);
 740            kDefaultJetBackgroundBranchMC = Form("%s_%s",AliAODJetEventBackground::StdBranchName(),taskCl->GetJetOutputBranch());
 741          kJetListSpectrum.Add(new TObjString(taskCl->GetJetOutputBranch()));
 742
 743            taskCl = AddTaskJetCluster("AODMC2","",kHighPtFilterMask,iPhysicsSelectionFlag,"KT",0.6,0,1, kDeltaAODJetName.Data(),0.15,fTrackEtaWindow); // this one is for the background and random jets
 744            taskCl->SetEventSelection(kTRUE); // saves some computing time, not all vertices are processed
 745            taskCl->SetBackgroundCalc(kTRUE);
 746            taskCl->SetGhostEtamax(fTrackEtaWindow);
 747            kDefaultJetBackgroundBranchMC2 = Form("%s_%s",AliAODJetEventBackground::StdBranchName(),taskCl->GetJetOutputBranch());
 748            if(iAODanalysis==2)taskCl->SetAODTrackInput(kTRUE);
 749            kJetListSpectrum.Add(new TObjString(taskCl->GetJetOutputBranch()));
 750            // pp background calcs...
 751          }
 752
 753          taskCl = AddTaskJetCluster("AODMC","",kHighPtFilterMask,iPhysicsSelectionFlag,"ANTIKT",0.4,0,1, kDeltaAODJetName.Data(),0.15,fTrackEtaWindow);
 754          taskCl->SetGhostEtamax(fTrackEtaWindow);
 755          taskCl->SetEventSelection(kTRUE); // saves some computing time, not all vertices are processed
 756          if(kIsPbPb)taskCl->SetBackgroundBranch(kDefaultJetBackgroundBranchMC.Data());
 757          kDefaultJetBranchMC = taskCl->GetJetOutputBranch();
 758          if(iAODanalysis==2)taskCl->SetAODTrackInput(kTRUE);
 759          kJetListSpectrum.Add(new TObjString(taskCl->GetJetOutputBranch()));
 760
 761          taskCl = AddTaskJetCluster("AODMC2","",kHighPtFilterMask,iPhysicsSelectionFlag,"ANTIKT",0.4,0,1, kDeltaAODJetName.Data(),0.15,fTrackEtaWindow);
 762          taskCl->SetEventSelection(kTRUE); // saves some computing time, not all vertices are processed
 763          if(kIsPbPb)taskCl->SetBackgroundBranch(kDefaultJetBackgroundBranchMC2.Data());
 764          kDefaultJetBranchMC2 = taskCl->GetJetOutputBranch();
 765          if(iAODanalysis==2)taskCl->SetAODTrackInput(kTRUE);
 766          kJetListSpectrum.Add(new TObjString(taskCl->GetJetOutputBranch()));
 767        }
 768
 769
 770        if (!taskCl) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskCluster cannot run for this train conditions - EXCLUDED");
 771      }
 772    }
 773
 774
 775    if(iJETSUBTRACT&&kJetSubtractBranches.Length()){
 776      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJetBackgroundSubtract.C");
 777      AliAnalysisTaskJetBackgroundSubtract *taskSubtract = 0;
 778      if(kJetSubtractBranches.Length()){
 779
 780
 781
 782
 783        for(int iB = 1;iB<3;iB++){
 784          if(iB>2)continue;
 785          taskSubtract = AddTaskJetBackgroundSubtract(kJetSubtractBranches,iB,kJetSubtractMask1.Data(),kJetSubtractMask2.Data());
 786          taskSubtract->SetBackgroundBranch(kDefaultJetBackgroundBranch.Data());         taskSubtract->SelectCollisionCandidates(iPhysicsSelectionFlag);
 787          if(kDeltaAODJetName.Length()>0)taskSubtract->SetNonStdOutputFile(kDeltaAODJetName.Data());
 788          //      taskSubtract->SetDebugLevel(10);
 789          TString cTmp;
 790          TObjArray *objArr = kJetSubtractBranches.Tokenize(" ");
 791          for(int iJB = 0;iJB<objArr->GetEntries();iJB++){
 792            TObjString *ostr = (TObjString*)objArr->At(iJB);
 793            cTmp = ostr->GetString().Data();
 794            cTmp.ReplaceAll(kJetSubtractMask1.Data(),Form(kJetSubtractMask2.Data(),iB));
 795            kJetListSpectrum.Add(new TObjString(cTmp.Data()));
 796          }
 797
 798          //     taskSubtract->SetDebugLevel(3);
 799          if(iB==2){
 800            if(kJetSubtractBranches.Contains(kDefaultJetBranch.Data())&&kIsPbPb){
 801              kDefaultJetBranch.ReplaceAll(taskSubtract->GetToReplace(),Form(taskSubtract->GetReplacementMask(),taskSubtract->GetSubtractionMethod()));
 802            }
 803          }
 804
 805        }
 806
 807        //
 808        // cut1
 809        Int_t iB = 2;
 810        taskSubtract = AddTaskJetBackgroundSubtract(kJetSubtractBranchesCut1,iB,kJetSubtractMask1.Data(),kJetSubtractMask2.Data(),"Cut2000");
 811        taskSubtract->SetBackgroundBranch(kDefaultJetBackgroundBranchCut1.Data());
 812        taskSubtract->SelectCollisionCandidates(iPhysicsSelectionFlag);
 813        if(kDeltaAODJetName.Length()>0)taskSubtract->SetNonStdOutputFile(kDeltaAODJetName.Data());
 814
 815        objArr = kJetSubtractBranchesCut1.Tokenize(" ");
 816        for(int iJB = 0;iJB<objArr->GetEntries();iJB++){
 817          TObjString *ostr = (TObjString*)objArr->At(iJB);
 818          cTmp = ostr->GetString().Data();
 819          cTmp.ReplaceAll(kJetSubtractMask1.Data(),Form(kJetSubtractMask2.Data(),iB));
 820          kJetListSpectrum.Add(new TObjString(cTmp.Data()));
 821        }
 822
 823
 824      }
 825      if(kJetSubtractBranches_extra.Length()){
 826        taskSubtract = AddTaskJetBackgroundSubtract(kJetSubtractBranches_extra,2,kJetSubtractMask1.Data(),kJetSubtractMask2.Data(),"extra");
 827        taskSubtract->SetBackgroundBranch(kDefaultJetBackgroundBranch_extra.Data());
 828        taskSubtract->SelectCollisionCandidates(iPhysicsSelectionFlag);
 829        //taskSubtract->SetDebugLevel(3);
 830        if(kDeltaAODJetName.Length()>0)taskSubtract->SetNonStdOutputFile(kDeltaAODJetName.Data());
 831        if(kJetSubtractBranches_extra.Contains(kDefaultJetBranch.Data())){
 832          kDefaultJetBranch.ReplaceAll(taskSubtract->GetToReplace(),Form(taskSubtract->GetReplacementMask(),taskSubtract->GetSubtractionMethod()));
 833        }
 834      }
 835      if (!taskSubtract) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskJetBackgroundSubtrac cannot run for this train conditions - EXCLUDED");
 836    }
 837
 838    if (iDIJETAN) {
 839       gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskDiJets.C");
 840       AliAnalysisTaskDiJets *taskdijets = 0;
 841       if(iDIJETAN&1)taskdijets = AddTaskDiJets();
 842       if (!taskdijets) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskJets cannot run for this train conditions - EXCLUDED");
 843       if(iDIJETAN&2){
 844         taskdijets = AddTaskDiJets("jetsAOD_CDF07");
 845         taskdijets = AddTaskDiJets("jetsAOD_DA07");
 846         taskdijets = AddTaskDiJets("jetsAOD_FASTJET07");
 847         taskdijets = AddTaskDiJets("jetsAOD_FASTKT07");
 848         taskdijets = AddTaskDiJets("jetsAOD_SISCONE07");
 849         taskdijets = AddTaskDiJets("jetsAOD_UA107");
 850       }
 851    }
 852
 853    if(iPWG1QASym){
 854      gROOT->LoadMacro("$ALICE_ROOT/PWG1/PilotTrain/AddTaskQAsym.C");
 855      AliAnalysisTaskQASym *taskQASym = AddTaskQAsym(-1);
 856      if (!taskQASym) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskQASym cannot run for this train conditions - EXCLUDED");
 857    }
 858
 859
 860
 861    if(iPWG4TmpSourceSara){
 862      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskEta.C");
 863      AliAnalysisTaskEta *taskEta = AddTaskEta();
 864      if (!taskEta) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskEta cannot run for this train conditions - EXCLUDED");
 865    }
 866
 867
 868    if(iPWG4JetServices){
 869      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJetServices.C");
 870      AliAnalysisTaskJetServices *taskjetServ = 0;
 871      taskjetServ = AddTaskJetServices();
 872      if (!taskjetServ) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskJetServices cannot run for this train conditions - EXCLUDED");
 873      if(kGridRunRange[0]>0)taskjetServ->SetRunRange(kGridRunRange[0],kGridRunRange[1]);
 874      else taskjetServ->SetRunRange(110000,160000);
 875      taskjetServ->SetMCData(kIsMC);
 876      taskjetServ->SetUsePhysicsSelection((Bool_t)iPhysicsSelection);
 877      taskjetServ->SetPhysicsSelectionFlag(iPhysicsSelectionFlag); //
 878      taskjetServ->SetNonStdFile(kDeltaAODJetName.Data());
 879      taskjetServ->SetTrackEtaWindow(fTrackEtaWindow);
 880      taskjetServ->SetFilterMask(kHighPtFilterMask);
 881      if(kIsPbPb)taskjetServ->SetCollisionType(AliAnalysisTaskJetServices::kPbPb);
 882      else taskjetServ->SetCollisionType(AliAnalysisTaskJetServices::kPP);
 883      if(kIsPbPb){
 884        if(kDeltaAODJetName.Length()>0&&kFilterAOD)taskjetServ->SetFilterAODCollisions(kTRUE);
 885        //       else if(iAODanalysis)taskjetServ->SetFilterAODCollisions(kTRUE);
 886        //       taskjetServ->SetDebugLevel(3);
 887        taskjetServ->SetZVertexCut(8.);
 888      }
 889      if(iAODanalysis){
 890        //
 891        taskjetServ->SetAODInput(kTRUE);
 892      }
 893    }
 894
 895    if(iPWG4JetSpectrum){
 896      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJetSpectrum2.C");
 897      AliAnalysisTaskJetSpectrum2 *taskjetSpectrum = 0;
 898      TString bkgClusters = kDefaultJetBackgroundBranch.Data();
 899      bkgClusters.ReplaceAll(Form("%s_",AliAODJetEventBackground::StdBranchName()),"");
 900      Printf("############# Possible jet branches ###################");
 901      for(int iJF = 0;iJF < kJetListSpectrum.GetSize();iJF++){
 902        TObjString *objStr = (TObjString*)kJetListSpectrum.At(iJF);
 903        Printf("%3d: %s",iJF+1,objStr->GetString().Data());
 904      }
 905
 906      // Printf("Type q to exit");if(getchar()=='q')return;
 907      if(iPWG4JetSpectrum&1){
 908        if(kIsPbPb){
 909          for(int iJF = 0;iJF < kJetListSpectrum.GetSize();iJF++){
 910            Long64_t value = kJetMapSpectrum(iJF+1);
 911            Printf("iJF: %d value: %d", iJF+1,(Int_t)value);
 912            if(value==0)continue;
 913            TObjString *objStr = (TObjString*)kJetListSpectrum.At(iJF);
 914            TString bName1 = objStr->GetString().Data();
 915            TString bName2[3];
 916
 917            TObjString *objStrBkg = (TObjString*)kJetListSpectrum.At(iJF);
 918            TString bBkgName1("");
 919            TString bBkgName2[3];
 920
 921            Long64_t valueBkg1 = kJetBackMapSpectrum(iJF+1);
 922            if(valueBkg1>0){
 923              TObjString *objStrBkg = (TObjString*)kJetListSpectrum.At(valueBkg1-1);
 924              bBkgName1 = objStrBkg->GetString().Data();
 925            }
 926            Int_t iPartner = 0;
 927            if(value>0){
 928              Int_t iJF2 = -1;
 929              for(int i = 0;i<3;i++){
 930                iJF2 = value/kJetMapOffset[i]-1;
 931                value = value%kJetMapOffset[i];
 932                Printf("%d %d", iJF2+1,(Int_t)value);
 933                if(iJF2>=0&&iJF2<kJetListSpectrum.GetSize()){
 934                  TObjString *objStr2 = (TObjString*)kJetListSpectrum.At(iJF2);
 935                  bName2[iPartner] = objStr2->GetString().Data();
 936                  Long64_t valueBkg2 = kJetBackMapSpectrum(iJF2+1);
 937                  if(valueBkg2>0){
 938                    TObjString *objStrBkg2 = (TObjString*)kJetListSpectrum.At(valueBkg2-1);
 939                    bBkgName2[iPartner] = objStrBkg2->GetString().Data();
 940                  }
 941                  iPartner++;
 942                }
 943              }
 944            }
 945
 946
 947            // loop over all centralities
 948            for(int ic = 0;ic<5;ic++){
 949              if(ic!=0)continue;
 950              Bool_t bDone = kFALSE;
 951              for(int i = 0;i<TMath::Max(iPartner,1);i++){
 952                if(bName2[i].Length()){
 953                  taskjetSpectrum = AddTaskJetSpectrum2(bName1.Data(),bName2[i].Data(),kDeltaAODJetName.Data(),kHighPtFilterMask,AliVEvent::kMB,0,ic);
 954                  bDone = kTRUE;
 955                }
 956                else{
 957                  if(!bDone){
 958                    taskjetSpectrum = AddTaskJetSpectrum2(bName1.Data(),bName2[i].Data(),kDeltaAODJetName.Data(),kHighPtFilterMask,AliVEvent::kMB,0,ic);
 959                    bDone = kTRUE;
 960                  }
 961                  else{
 962                    continue;
 963                  }
 964                }
 965                Printf("%s/%s %s/%s",bName1.Data(),bBkgName1.Data(),bName2[i].Data(),bBkgName2[i].Data());
 966
 967                // setting all the other things...
 968                taskjetSpectrum->SetTrackEtaWindow(fTrackEtaWindow);
 969                taskjetSpectrum->SetJetEtaWindow(fJetEtaWindow);
 970
 971                // negative values do not fill the track histos
 972                taskjetSpectrum->SetFlagJetType(AliAnalysisTaskJetSpectrum2::kJetGenFull,-1);
 973                taskjetSpectrum->SetFlagJetType(AliAnalysisTaskJetSpectrum2::kJetGen,-1);
 974                if(!bName1.Contains("ANTIKT")||bName1.Contains("Cone")){
 975                  taskjetSpectrum->SetFlagJetType(AliAnalysisTaskJetSpectrum2::kJetRecFull,-1);
 976                  taskjetSpectrum->SetFlagJetType(AliAnalysisTaskJetSpectrum2::kJetRec,-1);
 977                }
 978
 979
 980                if(bName2[i].Length()==0){
 981                  taskjetSpectrum->SetFlagJetType(AliAnalysisTaskJetSpectrum2::kJetGenFull,0);
 982                  taskjetSpectrum->SetFlagJetType(AliAnalysisTaskJetSpectrum2::kJetGen,0);
 983                }
 984                if(iAODanalysis==1){
 985                  taskjetSpectrum->SetAODJetInput(kTRUE);
 986                  taskjetSpectrum->SetAODTrackInput(kTRUE);
 987                }
 988                else if (iAODanalysis==2){
 989                  taskjetSpectrum->SetAODTrackInput(kTRUE);
 990                  taskjetSpectrum->SetAODJetInput(kFALSE);
 991                }
 992                //              taskjetSpectrum->SetDebugLevel(11);
 993                taskjetSpectrum->SetBranchBkgRec(bBkgName1.Data());
 994                taskjetSpectrum->SetBranchBkgGen(bBkgName2[i].Data());
 995              }
 996            }
 997          }
 998        }
 999        else{ // ! PbPb
1000          Int_t i = 0;
1001
1002          taskjetSpectrum = AddTaskJetSpectrum2(kDefaultJetBranch.Data(),
1003                                                "",kDeltaAODJetName.Data(),kHighPtFilterMask,AliVEvent::kMB,0,i);
1004
1005
1006
1007          if(kDefaultJetBranchMC.Length()){
1008            taskjetSpectrum = AddTaskJetSpectrum2(kDefaultJetBranch.Data(),
1009                                                kDefaultJetBranchMC.Data(),kDeltaAODJetName.Data(),kHighPtFilterMask,AliVEvent::kMB,0,i);
1010            //      taskjetSpectrum->SetMinJetPt(10);
1011            taskjetSpectrum->SetTrackEtaWindow(fTrackEtaWindow);
1012            taskjetSpectrum->SetJetEtaWindow(fJetEtaWindow);
1013            taskjetSpectrum->SetBranchBkgRec(bkgClusters.Data());
1014            taskjetSpectrum->SetBranchBkgGen(bkgClusters.Data());
1015            if(iAODanalysis)SetAODInput(taskjetSpectrum);
1016          }
1017          if(kDefaultJetBranchMC2.Length()){
1018            taskjetSpectrum = AddTaskJetSpectrum2(kDefaultJetBranch.Data(),
1019                                                  kDefaultJetBranchMC2.Data(),kDeltaAODJetName.Data(),kHighPtFilterMask,AliVEvent::kMB,0,i);
1020            //      taskjetSpectrum->SetMinJetPt(10);
1021            taskjetSpectrum->SetTrackEtaWindow(fTrackEtaWindow);
1022            taskjetSpectrum->SetJetEtaWindow(fJetEtaWindow);
1023            taskjetSpectrum->SetBranchBkgRec(bkgClusters.Data());
1024            taskjetSpectrum->SetBranchBkgGen(bkgClusters.Data());
1025            if(iAODanalysis)SetAODInput(taskjetSpectrum);
1026          }
1027
1028          /*
1029          TString tmp2(kDefaultJetBranch.Data());
1030          tmp2.ReplaceAll(Form(kJetSubtractMask2.Data(),0),Form(kJetSubtractMask2.Data(),2));
1031          taskjetSpectrum = AddTaskJetSpectrum2(tmp2.Data(),kDefaultJetBranch.Data(),kDeltaAODJetName.Data(),kHighPtFilterMask,AliVEvent::kMB,0,i);
1032          //      taskjetSpectrum->SetDebugLevel(3);
1033          //        taskjetSpectrum->SetMinJetPt(10);
1034          taskjetSpectrum->SetBranchBkgRec(bkgClusters.Data());
1035          taskjetSpectrum->SetBranchBkgGen(bkgClusters.Data());
1036          taskjetSpectrum->SetTrackEtaWindow(0.8);
1037          taskjetSpectrum->SetJetEtaWindow(0.4);
1038
1039          // check the old subtracted vs. the new subtracted
1040          TString tmp3(kDefaultJetBranch.Data());
1041          tmp3.ReplaceAll(Form(kJetSubtractMask2.Data(),0),Form(kJetSubtractMask2.Data(),3));
1042          taskjetSpectrum = AddTaskJetSpectrum2(tmp3.Data(),kDefaultJetBranch.Data(),kDeltaAODJetName.Data(),kHighPtFilterMask,AliVEvent::kMB,0,i);
1043          //      taskjetSpectrum->SetDebugLevel(3);
1044          //        taskjetSpectrum->SetMinJetPt(10);
1045          taskjetSpectrum->SetBranchBkgRec(bkgClusters.Data());
1046          taskjetSpectrum->SetBranchBkgGen(bkgClusters.Data());
1047          taskjetSpectrum->SetTrackEtaWindow(0.8);
1048          taskjetSpectrum->SetJetEtaWindow(0.4);
1049          if(iAODanalysis)SetAODInput(taskjetSpectrum);
1050          */
1051        }
1052        if (!taskjetSpectrum) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskJetSpectrum2 cannot run for this train conditions - EXCLUDED");
1053      }
1054    }
1055    AliAnalysisManager::SetCommonFileName("PWG4_Fragmentation.root");
1056    if(iPWG4Fragmentation){
1057      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskFragmentationFunction.C");
1058        AliAnalysisTaskFragmentationFunction *taskFrag = 0;
1059        if(kUseAODMC){
1060
1061        }
1062        else{
1063
1064
1065          for(int ic = 1;ic < 5;ic++){
1066            // Anti-kT
1067            taskFrag = AddTaskFragmentationFunction(1<<23,kHighPtFilterMask, ic);
1068            if(kDeltaAODJetName.Length()>0)taskFrag->SetNonStdFile(kDeltaAODJetName.Data());
1069            if(iAODanalysis==2)taskFrag->UseAODInputJets(kFALSE);
1070
1071            // UA1
1072            taskFrag = AddTaskFragmentationFunction(1<<0,kHighPtFilterMask, ic);
1073            if(kDeltaAODJetName.Length()>0)taskFrag->SetNonStdFile(kDeltaAODJetName.Data());
1074            if(iAODanalysis==2)taskFrag->UseAODInputJets(kFALSE);
1075
1076          // SISCONE
1077            if(ic==1){
1078              /*
1079                taskFrag = AddTaskFragmentationFunction(1<<28,kHighPtFilterMask, ic);
1080                taskFrag = AddTaskFragmentationFunction(1<<29,kHighPtFilterMask, ic);
1081                taskFrag = AddTaskFragmentationFunction(1<<30,kHighPtFilterMask, ic);
1082              */
1083
1084
1085
1086              // Anti-kT B2 - B3
1087              if(!iAODanalysis==1){
1088                taskFrag = AddTaskFragmentationFunction(1<<26,kHighPtFilterMask, ic);
1089                if(kDeltaAODJetName.Length()>0)taskFrag->SetNonStdFile(kDeltaAODJetName.Data());
1090                if(iAODanalysis==2)taskFrag->UseAODInputJets(kFALSE);
1091
1092                taskFrag = AddTaskFragmentationFunction(1<<27,kHighPtFilterMask, ic);
1093                if(kDeltaAODJetName.Length()>0)taskFrag->SetNonStdFile(kDeltaAODJetName.Data());
1094                if(iAODanalysis==2)taskFrag->UseAODInputJets(kFALSE);
1095              }
1096            }
1097
1098          }
1099
1100
1101        }
1102        if (!taskFrag) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskFragmentationFunction cannot run for this train conditions - EXCLUDED");
1103    }
1104
1105    if(iPWG4JetChem){
1106      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJetChem.C");
1107      AliAnalysisTask *taskChem = AddTaskJetChem(kHighPtFilterMask);
1108      if (!taskChem) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskJetChem cannot run for this train conditions - EXCLUDED");
1109    }
1110
1111    if (iPWG4JetResponse) {
1112      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJetResponse.C");
1113      AliAnalysisTask *taskJetResponse = 0;
1114
1115      if(iJETAN){
1116         taskJetResponse = AddTaskJetResponse("jets", "FASTJET", 0.4, kHighPtFilterMask, 0.15, 0);
1117         taskJetResponse = AddTaskJetResponse("jets", "FASTJET", 0.4, kHighPtFilterMask, 0.15, 1);
1118
1119         taskJetResponse = AddTaskJetResponse("jets", "UA1", 0.4, kHighPtFilterMask, 1., 0);
1120         taskJetResponse = AddTaskJetResponse("jets", "UA1", 0.4, kHighPtFilterMask, 1., 2);
1121      }
1122      if(iPWG4Cluster){
1123         taskJetResponse = AddTaskJetResponse("clusters", "ANTIKT", 0.4, kHighPtFilterMask, 0.15, 0);
1124         taskJetResponse = AddTaskJetResponse("clusters", "ANTIKT", 0.4, kHighPtFilterMask, 0.15, 1);
1125      }
1126      if (!taskJetResponse) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskJetResponse cannot run for this train conditions - EXCLUDED");
1127
1128    }
1129
1130    if(iPWG4JCORRAN){
1131      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJCORRANTask.C");
1132      AliJCORRANTask* corran = AddTaskJCORRAN(kDeltaAODJCORRANName.Data(),0);
1133      if(!corran)::Warning("AnalysisTrainPWG4Jets", "AliJCORRANTask cannot run for this train conditions - EXCLUDED");
1134      else{
1135        if(kDeltaAODJCORRANName.Length()>0)mgr->RegisterExtraFile(kDeltaAODJCORRANName.Data());
1136      }
1137    }
1138
1139    if(iPWG4UE){
1140      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskUE.C");
1141      AliAnalysisTaskUE *taskUE = 0;
1142      if(iPWG4UE&1)taskUE = AddTaskUE();
1143      if(iPWG4UE&2){
1144        taskUE  =AddTaskUE("jetsAOD_CDF04","CDF", "LJ", "TRANSV","MSP"); //finder not yet in train
1145        //       taskUE  =AddTaskUE("jetsAOD_CDF07","CDF", "LJ", "TRANSV","MSP");
1146        taskUE  =AddTaskUE("jetsAOD_SISCONE04","CDF", "LJ", "TRANSV","MSP");
1147        //       taskUE  =AddTaskUE("jetsAOD_SISCONE07","CDF", "LJ", "TRANSV","MSP"); //finder not yet in train
1148        taskUE  =AddTaskUE("jetsAOD_ICDF","CDF","LJ","TRANSV","MSP");
1149        taskUE  =AddTaskUE("jetsAOD_FASTKT04","CDF", "LJ", "TRANSV","MSP");
1150        //       taskUE  =AddTaskUE("jetsAOD_FASTKT07","CDF", "LJ", "TRANSV","MSP"); //finder not yet in train
1151        taskUE  =AddTaskUE("jetsAOD_NONE","CDF", "MP_eta05", "TRANSV","MSP");
1152        taskUE  =AddTaskUE("jetsAOD_NONE","CDF", "MP_eta09", "TRANSV","MSP");
1153      }
1154
1155      if (!taskUE) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskUE cannot run for this train conditions - EXCLUDED");
1156    }
1157
1158    if(iPWG4LeadingUE){
1159      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskLeadingTrackUE.C");
1160      AliAnalysisTaskLeadingTrackUE *taskLeadingUE = AddTaskLeadingTrackUE(kUseMC);
1161      if (!taskLeadingUE) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTasLeadingTrackkUE cannot run for this train conditions - EXCLUDED");
1162      //     taskLeadingUE->SetFilterBit(64);
1163    }
1164
1165
1166    if(iPWG4CorrectionsUE){
1167      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskCorrectionsUE.C");
1168      AliAnalysisTaskCorrectionsUE *taskCorrectionsUE = 0;
1169      if(iPWG4CorrectionsUE&1)taskCorrectionsUE = AddTaskCorrectionsUE("jetsAOD_NONE","CDF","MP_eta05","TRANSV","MSP",kFALSE);
1170      if (!taskCorrectionsUE) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskCorrectionsUE cannot run for this train conditions - EXCLUDED");
1171    }
1172
1173    if(iPWG4ThreeJets){
1174      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskThreeJets.C");
1175      AliAnalysisTaskThreeJets *taskThree = AddTaskThreeJets();
1176      if(!taskThree)::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskThreets cannot run for this train conditions - EXCLUDED");
1177    }
1178    if(iPWG4QGSep){
1179      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskQGSep.C");
1180      AliAnalysisTaskQGSep *taskQGSep = AddTaskQGSep(kUseMC,iAODanalysis);
1181      if(!taskQGSep)::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskQGSep cannot run for this train conditions - EXCLUDED");
1182    }
1183
1184
1185    if(iPWG4Minijet){
1186      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskMinijet.C");
1187      AliAnalysisTaskMinijet *taskMini = AddTaskMinijet(-1,"esd",kUseMC,kGridDataSet);
1188      // if we ha highmult trigger add another task
1189      if(!taskMini)::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskMinjet cannot run for this train conditions - EXCLUDED");
1190    }
1191
1192    AliAnalysisManager::SetCommonFileName("PWG4_HighPtQA.root");
1193    if(iPWG4PtQAMC){
1194      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskPWG4HighPtQAMC.C");
1195      AliPWG4HighPtQAMC *taskQAMC = 0;
1196      if(kUseMC){
1197        if(iPWG4PtQAMC&1){
1198          taskQAMC = AddTaskPWG4HighPtQAMCAll(kGridDataSet.Data(),isPbPb,iAODanalysis);
1199        }
1200      }
1201      if (!taskQAMC) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskQAMC cannot run for this train conditions - EXCLUDED");
1202    }
1203
1204    if(iPWG4PtTrackQA){
1205      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskPWG4HighPtTrackQA.C");
1206      if(iPWG4PtTrackQA&2)AddTaskPWG4HighPtTrackQAAll(kGridDataSet.Data(),kIsPbPb,iAODanalysis);
1207      else AddTaskPWG4HighPtTrackQAAllReduced(kGridDataSet.Data(),kIsPbPb,iAODanalysis);
1208    }
1209
1210    if(iPWG4PtQATPC){
1211      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskPWG4HighPtQATPConly.C");
1212      AliPWG4HighPtQATPConly *taskQATPC = 0;
1213      if(iPWG4PtQATPC&1)taskQATPC = AddTaskPWG4HighPtQATPConly(kGridDataSet.Data(),1);
1214      if(iPWG4PtQATPC&2)taskQATPC = AddTaskPWG4HighPtQATPConly(kGridDataSet.Data(),2);
1215
1216  if (!taskQATPC) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskQATPC cannot run for this train conditions - EXCLUDED");
1217    }
1218
1219    if(iPWG4Cosmics){
1220      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskPWG4CosmicCandidates.C");
1221
1222      AliPWG4CosmicCandidates *taskPWG4CosmicCandidates = AddTaskPWG4CosmicCandidates(0);
1223      taskPWG4CosmicCandidates = AddTaskPWG4CosmicCandidates(1);
1224
1225      if (!taskPWG4CosmicCandidates) ::Warning("AnalysisTrainPWG4Jets", "AddTaskPWG4CosmicCandidates cannot run for this train conditions - EXCLUDED");
1226    }
1227
1228
1229    if(iPWG4PtSpectra){
1230      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskPWG4HighPtSpectra.C");
1231      AddTaskPWG4HighPtSpectraAll(kGridDataSet.Data(),kIsPbPb,iAODanalysis);
1232    }
1233
1234    if(iPWG4KMeans){
1235      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskKMeans.C");
1236      AliAnalysisTaskKMeans *taskKMeans = AddTaskKMeans();
1237      if (!taskKMeans) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskKMenans cannot run for this train conditions - EXCLUDED");
1238    }
1239
1240    if(iPWG4PartCorr){
1241      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskPartCorr.C");
1242      AliAnalysisTaskParticleCorrelation *taskpartcorrPHOS = AddTaskPartCorr("AOD", "PHOS",kFALSE,kIsMC);
1243      if (!taskpartcorrPHOS) ::Warning("AnalysisTrainNew", "AliAnalysisTaskParticleCorrelation PHOS cannot run for this train conditions - EXCLUDED");
1244      AliAnalysisTaskParticleCorrelation *taskpartcorrEMCAL = AddTaskPartCorr("AOD", "EMCAL",kFALSE,kIsMC);
1245      if (!taskpartcorrEMCAL) ::Warning("AnalysisTrainNew", "AliAnalysisTaskParticleCorrelation EMCAL cannot run for this train conditions - EXCLUDED");
1246      if(kDeltaAODPartCorrName.Length()>0)mgr->RegisterExtraFile(kDeltaAODPartCorrName.Data());
1247    }
1248
1249    if(iPWG4CaloQA){
1250      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/QA/AddTaskCalorimeterQA.C");
1251      AliAnalysisTaskParticleCorrelation *taskcaloQA =  AddTaskCalorimeterQA("ESD",kFALSE,kIsMC,kCaloQAOutputFileName.Data());
1252      if(!taskcaloQA)::Warning("AnalysisTrainNew", "AliAnalysisTaskParticleCorrelation QA cannot run - EXCLUDED");
1253      //  if(kCaloQAOutputFileName.Length()>0)mgr->RegisterExtraFile(kCaloQAOutputFileName.Data());
1254    }
1255
1256    if(iPWG4JetCorr){
1257      //     using namespace JetCorrelHD;
1258      TString cdir = gSystem->WorkingDirectory();
1259      gSystem->ChangeDirectory(gSystem->ExpandPathName("$ALICE_ROOT/PWG4/macros/"));
1260      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJetCorrel.C");
1261      AliAnalysisTaskJetCorrel *taskjetcorr = AddTaskJetCorrel();
1262      gSystem->ChangeDirectory(cdir);
1263      if (!taskjetcorr) ::Warning("AnalysisTrainNew", "AliAnalysisTaskJetCorrel  cannot run for this train conditions - EXCLUDED");
1264    }
1265
1266    if(iPWG4Tagged){
1267      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskTaggedPhotons.C");
1268      AliAnalysisTaskTaggedPhotons * taskTagged = AddTaskTaggedPhotons(kFALSE); // EMCAL
1269      taskTagged = AddTaskTaggedPhotons(kTRUE); // PHOS
1270      if (!taskTagged) ::Warning("AnalysisTrainNew", "AliAnalysisTaskTaggedPhotons  cannot run for this train conditions - EXCLUDED");
1271    }
1272    if (iPWG4omega3pi) {
1273      gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskomega3pi.C");
1274      AliAnalysisTaskOmegaPi0PiPi *taskomega3pi = AddTaskomega3pi();
1275      if (!taskomega3pi) ::Warning("AnalysisTrainNew", "AliAnalysisTaskomega3pi cannot run\
1276  for these train conditions - EXCLUDED");
1277    }
1278
1279    // PWG4 gamma conversion analysis
1280    if (iPWG4GammaConv) {
1281       gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskGammaConversion.C");
1282       TString cdir = gSystem->WorkingDirectory();
1283       gSystem->ChangeDirectory(gSystem->ExpandPathName("$ALICE_ROOT/PWG4/macros/"));
1284       //      TString gcArguments = "-run-on-train -run-jet -run-chic -run-neutralmeson -run-cf";
1285       //      TString gcArguments = "-run-on-train -run-jet -run-neutralmeson -run-cf -use-own-xyz";
1286       //      TString gcArguments = "-run-on-train -run-jet -run-neutralmeson -run-cf -use-own-xyz";
1287       TString gcArguments = "-run-on-train -run-jet -run-omega-meson -use-own-xyz -run-neutralmeson -no-aod";
1288       //      TString kGCAnalysisCutSelectionId="9003562000100310";
1289       //      TString kGCAnalysisCutSelectionId="9003562000100312";
1290       //      gcArguments.Append(Form(" -set-cut-selection %s ",kGCAnalysisCutSelectionId.Data()));
1291       if(!kIsMC)gcArguments += " -mc-off";
1292       AliAnalysisTaskGammaConversion * taskGammaConversion = AddTaskGammaConversion(gcArguments,mgr->GetCommonInputContainer());
1293       gSystem->ChangeDirectory(cdir);
1294       taskGammaConversion->SelectCollisionCandidates();
1295       if (!taskGammaConversion) ::Warning("AnalysisTrainNew", "AliAnalysisTaskGammaConversion cannot run for these train conditions - EXCLUDED");
1296    }
1297
1298    if (iPWG4CaloConv) {
1299       gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskCaloConv.C");
1300       AliAnalysisTaskCaloConv * taskCaloConv = AddTaskCaloConv();
1301       if (!taskCaloConv) ::Warning("AnalysisTrainNew", "AliAnalysisTaskCaloConv cannot run for these train conditions - EXCLUDED");
1302    }
1303
1304
1305
1306    //==========================================================================
1307    // FOR THE REST OF THE TASKS THE MACRO AddTaskXXX() is not yet implemented/
1308    // Run the analysis
1309    //
1310    if (kPluginUse) {
1311       AliAnalysisGrid *alienHandler = CreateAlienHandler(plugin_mode);
1312       AliAnalysisManager::GetAnalysisManager()->SetGridHandler(alienHandler);
1313    }
1314
1315    if (mgr->InitAnalysis()) {
1316      mgr->PrintStatus();
1317      // if (kSaveTrain || strlen(config_file)) gSystem->ChangeDirectory(kTrainName);
1318      if (!strcmp(plugin_mode,"submit")&&smode=="GRID"){
1319        TString alien_workdir = gGrid->GetHomeDirectory();
1320        if (iAODanalysis) alien_workdir += "analysisAOD";
1321        else              alien_workdir += "analysisESD";
1322        if(kGridDataSet.Length()>0)alien_workdir += Form("/%s%s",kGridDataSet.Data(),kGridExtraAliendirLevel.Data());
1323        AliAnalysisAlien *gridhandler = (AliAnalysisAlien*)mgr->GetGridHandler();
1324        printf("=== AnalysisTrainPWG4Jets:: Registering jdl in the work directory alien://%s/%s, should be done by the manager! ===\n",
1325               alien_workdir.Data(),gridhandler->GetGridOutputDir());
1326
1327        TString dest;
1328        dest = Form("%s/%s/%s.jdl",alien_workdir.Data(),gridhandler->GetGridOutputDir(),kTrainName.Data());
1329        if(AliAnalysisAlien::FileExists(dest.Data())){
1330          Printf("%s exist on grid removing...",dest.Data());
1331          gGrid->Rm(dest.Data());
1332        }
1333        Printf("%s copy ...",dest.Data());
1334        TFile::Cp(Form("file:%s.jdl",kTrainName.Data()),Form("alien://%s",dest.Data()));
1335
1336
1337        TString dest;
1338        dest = Form("%s/%s/%s_merge.jdl",alien_workdir.Data(),gridhandler->GetGridOutputDir(),kTrainName.Data());
1339        if(AliAnalysisAlien::FileExists(dest.Data())){
1340          Printf("%s exist on grid removing...",dest.Data());
1341          gGrid->Rm(dest.Data());
1342        }
1343        Printf("%s copy ...",dest.Data());
1344        TFile::Cp(Form("file:%s_merge.jdl",kTrainName.Data()),Form("alien://%s",dest.Data()));
1345
1346        dest = Form("%s/%s/%s_merge_final.jdl",alien_workdir.Data(),gridhandler->GetGridOutputDir(),kTrainName.Data());
1347        if(AliAnalysisAlien::FileExists(dest.Data())){
1348          Printf("%s exist on grid removing...",dest.Data());
1349          gGrid->Rm(dest.Data());
1350        }
1351        Printf("%s copy ...",dest.Data());
1352        TFile::Cp(Form("file:%s_merge.jdl",kTrainName.Data()),Form("alien://%s",dest.Data()));
1353      }
1354      AliLog::SetGlobalLogLevel(AliLog::kError);
1355      if((kUseSysInfo>0&&smode=="LOCAL")||!strcmp(plugin_mode, "test")){
1356        TFile * fM = TFile::Open("manager_local.root","RECREATE");
1357        mgr->Write();
1358        fM->Close();
1359      }
1360
1361      // grmpf, aliroot error handler overwrites root
1362      gErrorIgnoreLevel = kErrorIgnoreLevel;
1363      if(gErrorIgnoreLevel>3000) AliLog::SetGlobalLogLevel(AliLog::kFatal);
1364      StartAnalysis(smode, chain);
1365      if((kUseSysInfo>0&&smode=="LOCAL")||!strcmp(plugin_mode, "test")){
1366        for(int i = 0;i < mgr->GetTopTasks()->GetEntries();i++){
1367          mgr->ProfileTask(i);
1368        }
1369      }
1370      if (!strcmp(plugin_mode, "offline")&&smode=="GRID"){
1371        // Offline mode path files
1372        //       PatchJDL();
1373        //       PatchAnalysisMacro();
1374      }
1375
1376      if (kSaveTrain && smode=="GRID") {
1377        AliAnalysisAlien *gridhandler = (AliAnalysisAlien*)mgr->GetGridHandler();
1378        TString alien_workdir = gGrid->GetHomeDirectory();
1379        if (iAODanalysis) alien_workdir += "analysisAOD";
1380        else              alien_workdir += "analysisESD";
1381        if(kGridDataSet.Length()>0)alien_workdir += Form("/%s%s",kGridDataSet.Data(),kGridExtraAliendirLevel.Data());
1382        //     kGridOutdir = gridhandler->GetGridOutputDir();
1383        printf("=== Registering ConfigTrain.C in the work directory <%s> ===\n",
1384                 alien_workdir.Data());
1385        if (AliAnalysisAlien::FileExists(Form("%s/%sConfig.C", alien_workdir.Data(), kTrainName.Data())))
1386          gGrid->Rm(Form("%s/%sConfig.C", alien_workdir.Data(), kTrainName.Data()));
1387        if (strcmp(plugin_mode, "test"))
1388          TFile::Cp(Form("file:%sConfig.C",kTrainName.Data()), Form("alien://%s/%sConfig.C", alien_workdir.Data(), kTrainName.Data()));
1389      }
1390    }
1391 }
1392
1393 //______________________________________________________________________________
1394 void StartAnalysis(const char *mode, TChain *chain) {
1395 // Start analysis.
1396    Int_t imode = -1;
1397    AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
1398    if (!strcmp(mode, "LOCAL")) imode = 0;
1399    if (!strcmp(mode, "PROOF")) imode = 1;
1400    if (!strcmp(mode, "GRID"))  imode = 2;
1401    switch (imode) {
1402       case 0:
1403          if (!chain) {
1404             ::Error("AnalysisTrainPWG4Jets.C::StartAnalysis", "Cannot create the chain");
1405             return;
1406          }
1407          mgr->StartAnalysis(mode, chain,kNumberOfEvents);
1408          return;
1409       case 1:
1410          if (!kProofDataSet.Length()) {
1411             ::Error("AnalysisTrainPWG4Jets.C::StartAnalysis", "kProofDataSet is empty");
1412             return;
1413          }
1414          mgr->StartAnalysis(mode, kProofDataSet, kProofEvents,kProofOffset);
1415          return;
1416       case 2:
1417          if (kPluginUse) {
1418             if (!mgr->GetGridHandler()) {
1419                ::Error("AnalysisTrainPWG4Jets.C::StartAnalysis", "Grid plugin not initialized");
1420                return;
1421             }
1422             mgr->StartAnalysis("grid",chain,kNumberOfEvents);
1423          } else {
1424             if (!chain) {
1425                ::Error("AnalysisTrainPWG4Jets.C::StartAnalysis", "Cannot create the chain");
1426                return;
1427             }
1428             //            mgr->StartAnalysis(mode, chain);
1429             mgr->StartAnalysis(mode, chain,kNumberOfEvents);
1430          }
1431          return;
1432    }
1433 }
1434
1435 //______________________________________________________________________________
1436 void CheckModuleFlags(const char *mode) {
1437 // Checks selected modules and insure compatibility
1438    Int_t imode = -1;
1439    if (!strcmp(mode, "LOCAL")) imode = 0;
1440    if (!strcmp(mode, "PROOF")) imode = 1;
1441    if (!strcmp(mode, "GRID"))  imode = 2;
1442
1443
1444    if (kUseCPAR) {
1445      kPluginAliRootVersion    = ""; // NO aliroot if we use CPAR
1446    }
1447
1448    if (imode==1) {
1449       if (!kUsePAR) {
1450          ::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PAR files enabled due to PROOF analysis");
1451          kUsePAR = kTRUE;
1452       }
1453    }
1454    if (imode != 2) {
1455       ::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "AliEn plugin disabled since not in GRID mode");
1456       kPluginUse = kFALSE;
1457    }
1458
1459
1460    if(!kIsMC){
1461      // switch off anthin related to MC
1462      kUseMC = 0;
1463      kUseAODMC = 0;
1464      kUseTR = kFALSE;
1465    }
1466
1467    // Decide if we have PbPb
1468    if(kGridDataSet.CompareTo("LHC10h")==0||kGridDataSet.Contains("LHC10h")) {
1469      Printf("Using settings for Pb+Pb");
1470      kIsPbPb = true;
1471    }
1472
1473
1474
1475    if (iAODanalysis) {
1476    // AOD analysis
1477       if (kUseMC)
1478          ::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "MC usage disabled in analysis on AOD's");
1479       if (kUseAODTags)
1480          ::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "AOD tags usage disabled in analysis on AOD's");
1481       kUseMC = kFALSE;
1482       kUseTR = kFALSE;
1483       kUseAODTags = kFALSE;
1484       if (iESDfilter)
1485          ::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "ESD filter disabled in analysis on AOD's");
1486       iESDfilter   = 0;
1487       if (iPhysicsSelection)
1488          ::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "Physics Selection disabled in analysis on AOD's");
1489       iPhysicsSelection   = 0;
1490       if (!iAODhandler) {
1491          if (iJETAN)
1492             ::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "JETAN disabled in analysis on AOD's without AOD handler");
1493          iJETAN = 0;
1494          iDIJETAN = 0;
1495       }
1496       // Disable tasks that do not work yet on AOD data
1497       if(iPWG4JCORRAN)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG4 JCORRAN disabled in analysis on AOD's");
1498       iPWG4JCORRAN = 0;
1499       if( iPWG4PtQAMC)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG4 PtQAMC disabled in analysis on AOD's");
1500       iPWG4PtQAMC        = 0;
1501       if( iPWG4PtQATPC)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG4 PtTPC disabled in analysis on AOD's");
1502       iPWG4PtQATPC        = 0;
1503       if( iPWG4Cosmics)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG4 Comics disabled in analysis on AOD's");
1504       iPWG4Cosmics        = 0;
1505
1506       if(iPWG4KMeans)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG4KMeans disabled on AOD's");
1507       iPWG4KMeans       = 0;
1508       if (iPWG4JetCorr)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG4Jetcorr disabled on AOD's");
1509       iPWG4JetCorr = 0;
1510       if (iPWG4PartCorr)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG4partcorr disabled on AOD's");
1511       iPWG4PartCorr = 0;
1512       if (iPWG4CaloQA)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG4CaloQA disabled on AOD's");
1513       iPWG4CaloQA = 0;
1514       if (iPWG4Tagged)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG4tagged disabled on AOD's");
1515       iPWG4Tagged = 0;
1516       if (iPWG4omega3pi)
1517         ::Info("AnalysisTrainNew.C::CheckModuleFlags", "PWG4omega3pi disabled on AOD's");
1518       iPWG4omega3pi = 0;
1519       if(iPWG1QASym)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG1 QA Sym disabled in analysis on AOD's");
1520       if (iPWG4GammaConv)::Info("AnalysisPWG4Jets.C::CheckModuleFlags", "PWG4gammaconv disabled on AOD's");
1521       iPWG4GammaConv = 0;
1522       iPWG1QASym     = 0;
1523       iCentralitySelection = 0;
1524    } else {
1525    // ESD analysis
1526
1527      if(kIsPbPb){
1528        iCentralitySelection = 1;
1529      }
1530
1531      if (!kUseMC){
1532        kUseTR = kFALSE;
1533
1534        if(kUseKinefilter)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG4 Kine Filter disabled in analysis without MC");
1535        kUseKinefilter = kFALSE;
1536        if( iPWG4PtQAMC)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG4 PtQAMC disabled in analysis without MC");
1537        iPWG4PtQAMC        = 0;
1538        if( iPWG4CorrectionsUE)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG4 CorrectionsUE disabled in analysis without MC");
1539        iPWG4CorrectionsUE = 0;
1540      }
1541      if (iJETAN){
1542        iESDfilter=1;
1543      }
1544       if (!iESDfilter){
1545         kUseKinefilter = kFALSE;
1546         kUseMuonfilter = kFALSE;
1547       }
1548       if(!iJETAN){
1549         iPWG4JetSpectrum = iPWG4UE =  iPWG4CorrectionsUE = iPWG4ThreeJets = iPWG4QGSep = iDIJETAN = 0;
1550       }
1551    }
1552    iPWG4JetTasks = iPWG4JetServices||iPWG4JetSpectrum||iPWG4UE||iPWG4LeadingUE||iPWG4PtQAMC||iPWG4PtTrackQA||iPWG4PtSpectra||iPWG4PtQATPC||iPWG4Cosmics||iPWG4ThreeJets||iPWG4QGSep||iPWG4JetChem||iPWG4Minijet||iPWG4Fragmentation;
1553    iPWG4PartCorrLibs = iPWG4PartCorr||iPWG4Tagged||iPWG4CaloQA;
1554    iPWG4GammaConvLib = iPWG4GammaConv||iPWG4CaloConv;
1555
1556
1557    iEMCUtilLibs = iPWG4JetTasks||iPWG4PartCorrLibs||iPWG4JCORRAN||iPWG4GammaConvLib||iJETAN;
1558    iJETANLib = iPWG4JetTasks||iJETAN||iDIJETAN;
1559
1560    if (iESDfilter) {iAODhandler=1;}
1561    if (kUseKinefilter && !kUseMC) kUseKinefilter = kFALSE;
1562    if (kUseAODTags && !iAODhandler) kUseAODTags = kFALSE;
1563
1564
1565
1566 }
1567
1568 //______________________________________________________________________________
1569 Bool_t Connect(const char *mode) {
1570 // Connect <username> to the back-end system.
1571    Int_t imode = -1;
1572    if (!strcmp(mode, "LOCAL")) imode = 0;
1573    if (!strcmp(mode, "PROOF")) imode = 1;
1574    if (!strcmp(mode, "GRID"))  imode = 2;
1575    TString username = gSystem->Getenv("alien_API_USER");
1576    switch (imode) {
1577       case 0:
1578          break;
1579       case 1:
1580          if  (!username.Length()) {
1581             ::Error(Form("AnalysisTrainPWG4Jets.C::Connect <%s>", mode), "Make sure you:\n \
1582                            1. Have called: alien-token-init <username>\n \
1583                            2. Have called: >source /tmp/gclient_env_$UID");
1584             return kFALSE;
1585          }
1586          ::Info("AnalysisTrainPWG4Jets.C::Connect", "Connecting user <%s> to PROOF cluster <%s>",
1587                 username.Data(), kProofCluster.Data());
1588          gEnv->SetValue("XSec.GSI.DelegProxy", "2");
1589 //         TProof::Open(Form("%s@%s:31093", username.Data(), kProofCluster.Data()));
1590          TProof::Open(Form("%s@%s", username.Data(), kProofCluster.Data()));
1591          if (!gProof) {
1592             if (strcmp(gSystem->Getenv("XrdSecGSISRVNAMES"), "lxfsrd0506.cern.ch"))
1593                ::Error(Form("AnalysisTrainPWG4Jets.C::Connect <%s>", mode), "Environment XrdSecGSISRVNAMES different from lxfsrd0506.cern.ch");
1594             return kFALSE;
1595          }
1596          if(kProofClearPackages)gProof->ClearPackages();
1597
1598          if(kProofSaveToAlien){
1599            TGrid::Connect("alien://");
1600            if (gGrid) {
1601              TString homedir = gGrid->GetHomeDirectory();
1602              TString workdir = homedir + kTrainName;
1603              if (!gGrid->Cd(workdir)) {
1604                gGrid->Cd(homedir);
1605                if (gGrid->Mkdir(workdir)) {
1606                  gGrid->Cd(kTrainName);
1607                  ::Info("AnalysisTrainPWG4Jets::Connect()", "Directory %s created", gGrid->Pwd());
1608                }
1609              }
1610              gGrid->Mkdir("proof_output");
1611              gGrid->Cd("proof_output");
1612              kProofOutdir = Form("alien://%s", gGrid->Pwd());
1613            }
1614          }
1615          break;
1616       case 2:
1617          if  (!username.Length()) {
1618             ::Error(Form("AnalysisTrainPWG4Jets.C::Connect <%s>", mode), "Make sure you:\n \
1619                            1. Have called: alien-token-init <username>\n \
1620                            2. Have called: >source /tmp/gclient_env_$UID");
1621             return kFALSE;
1622          }
1623          if (kPluginUse && !gSystem->Getenv("alien_CLOSE_SE")) {
1624             ::Error(Form("AnalysisTrainPWG4Jets.C::Connect <%s>", mode),
1625                            "When using the AliEn plugin it is preferable to define the \
1626                            variable alien_CLOSE_SE in your environment.");
1627             return kFALSE;
1628          }
1629          ::Info("AnalysisTrainPWG4Jets.C::Connect", "Connecting user <%s> to AliEn ...",
1630                 username.Data());
1631          TGrid::Connect("alien://");
1632          if (!gGrid || !gGrid->IsConnected()) return kFALSE;
1633          break;
1634       default:
1635          ::Error("AnalysisTrainPWG4Jets.C::Connect", "Unknown run mode: %s", mode);
1636          return kFALSE;
1637    }
1638    ::Info("AnalysisTrainPWG4Jets.C::Connect","Connected in %s mode", mode);
1639    return kTRUE;
1640 }
1641
1642 //______________________________________________________________________________
1643 Bool_t LoadCommonLibraries(const char *mode)
1644 {
1645    if (!gSystem->Getenv("ALICE_ROOT")) {
1646       ::Error("AnalysisTrainPWG4Jets.C", "Analysis train requires that ALICE_ROOT is set to pick up Configurations");
1647       return kFALSE;
1648    }
1649
1650    // Load common analysis libraries.
1651    Int_t imode = -1;
1652    if (!strcmp(mode, "LOCAL")) imode = 0;
1653    if (!strcmp(mode, "PROOF")) imode = 1;
1654    if (!strcmp(mode, "GRID"))  imode = 2;
1655    Bool_t success = kTRUE;
1656    // ROOT libraries
1657    gSystem->Load("libTree.so");
1658    gSystem->Load("libGeom.so");
1659    gSystem->Load("libVMC.so");
1660    gSystem->Load("libPhysics.so");
1661
1662    // Load framework classes. Par option ignored here.
1663    switch (imode) {
1664       case 0:
1665       case 2:
1666          if (kUseCPAR) {
1667             success &= LoadLibrary("STEERBase", mode, kTRUE);
1668             success &= LoadLibrary("ESD", mode, kTRUE);
1669             success &= LoadLibrary("AOD", mode, kTRUE);
1670             success &= LoadLibrary("ANALYSIS", mode, kTRUE);
1671             success &= LoadLibrary("OADB", mode, kTRUE);
1672             success &= LoadLibrary("ANALYSISalice", mode, kTRUE);
1673             success &= LoadLibrary("ROOTFILES", mode, kTRUE);
1674             //            success &= LoadLibrary("EventMixing", mode,kTRUE);
1675             success &= LoadLibrary("CORRFW", mode, kTRUE);
1676          } else {
1677             success &= LoadLibrary("libSTEERBase.so", mode);
1678             success &= LoadLibrary("libESD.so", mode);
1679             success &= LoadLibrary("libAOD.so", mode);
1680             success &= LoadLibrary("libANALYSIS.so", mode);
1681             success &= LoadLibrary("libOADB.so", mode, kTRUE);
1682             success &= LoadLibrary("libANALYSISalice.so", mode);
1683             //            success &= LoadLibrary("libEventMixing.so", mode);
1684             success &= LoadLibrary("libCORRFW.so", mode);
1685             gROOT->ProcessLine(".include $ALICE_ROOT/include");
1686          }
1687          break;
1688       case 1:
1689          Int_t ires = -1;
1690          if (kProofUseAFPAR && !gSystem->AccessPathName(kProofAFversion)) ires = gProof->UploadPackage(kProofAFversion);
1691          if (ires < 0) {
1692             success &= LoadLibrary("STEERBase", mode);
1693             success &= LoadLibrary("ESD", mode);
1694             success &= LoadLibrary("AOD", mode);
1695             success &= LoadLibrary("ANALYSIS", mode);
1696             success &= LoadLibrary("ANALYSISalice", mode);
1697             success &= LoadLibrary("EventMixing", mode);
1698             success &= LoadLibrary("CORRFW", mode);
1699          } else {
1700             ires = gProof->EnablePackage(kProofAFversion);
1701             if (ires<0) success = kFALSE;
1702             success &= LoadLibrary("CORRFW", mode);
1703          }
1704          break;
1705       default:
1706          ::Error("AnalysisTrainPWG4Jets.C::LoadCommonLibraries", "Unknown run mode: %s", mode);
1707          return kFALSE;
1708    }
1709    if (success) {
1710       ::Info("AnalysisTrainPWG4Jets.C::LoadCommodLibraries", "Load common libraries:    SUCCESS");
1711       ::Info("AnalysisTrainPWG4Jets.C::LoadCommodLibraries", "Include path for Aclic compilation:\n%s",
1712               gSystem->GetIncludePath());
1713    } else {
1714       ::Info("AnalysisTrainPWG4Jets.C::LoadCommodLibraries", "Load common libraries:    FAILED");
1715    }
1716
1717    return success;
1718 }
1719
1720 //______________________________________________________________________________
1721 Bool_t LoadAnalysisLibraries(const char *mode)
1722 {
1723 // Load common analysis libraries.
1724   Bool_t success = kTRUE;
1725   if (useTender) {
1726       if (!LoadLibrary("TENDER", mode, kTRUE) ||
1727           !LoadLibrary("TENDERSupplies", mode, kTRUE)) return kFALSE;
1728    }
1729    if (iESDfilter) {
1730      /*
1731       if (!LoadLibrary("PWG3base", mode, kTRUE) ||
1732           !LoadLibrary("PWG3muon", mode, kTRUE)) return kFALSE;
1733      */
1734    }
1735    // JETAN
1736    if (iJETANLib) {
1737      // this part needs some rework in case we do not need the fastjed finders for processing
1738      if(iEMCUtilLibs){
1739        if (!LoadLibrary("EMCALUtils", mode, kTRUE) ||
1740            !LoadLibrary("PHOSUtils", mode, kTRUE)) return kFALSE;
1741      }
1742      if (!LoadLibrary("JETAN", mode, kTRUE)) return kFALSE;
1743      if (!strcmp(mode, "PROOF")){
1744        gProof->Exec("gSystem->Load\(\"/afs/cern.ch/user/d/dperrino/public/libCGAL.so\"\)", kTRUE);
1745        gProof->Exec("gSystem->Load\(\"/afs/cern.ch/user/d/dperrino/public/libfastjet.so\"\)", kTRUE);
1746        // problem when loading siscone copiled with different gcc version??
1747        // gProof->Exec("gSystem->Load\(\"/afs/cern.ch/user/d/dperrino/public/libsiscone.so\"\)", kTRUE);
1748        gProof->Exec("gSystem->Load\(\"/afs/cern.ch/user/d/dperrino/public/libSISConePlugin.so\"\)", kTRUE);
1749      }
1750      if(!kUsePAR){
1751        if (!LoadLibrary("CGAL", mode, kTRUE)) return kFALSE;
1752        if (!LoadLibrary("fastjet", mode, kTRUE)) return kFALSE;
1753        if (!LoadLibrary("siscone", mode, kTRUE)) return kFALSE;
1754        if (!LoadLibrary("SISConePlugin", mode, kTRUE)) return kFALSE;
1755      }
1756      else{
1757        // par files plus FASTJET needs some extra work... need to change
1758        // the loading sequence in the auto generated .C file
1759        if (!LoadLibrary("libCGAL.so", mode, kTRUE)) return kFALSE;
1760        if (!LoadLibrary("libfastjet.so", mode, kTRUE)) return kFALSE;
1761        if (!LoadLibrary("libsiscone.so", mode, kTRUE)) return kFALSE;
1762        if (!LoadLibrary("libSISConePlugin.so", mode, kTRUE)) return kFALSE;
1763      }
1764      if (!LoadLibrary("FASTJETAN", mode, kTRUE)) return kFALSE;
1765    }
1766    if(iPWG4JetTasks){
1767      if (!LoadLibrary("PWG4JetTasks", mode, kTRUE)) return kFALSE;
1768    }
1769
1770    if(iPWG1QASym){
1771      if (!LoadSource(Form("%s/PWG1/AliAnalysisTaskQASym.cxx",gSystem->ExpandPathName("$ALICE_ROOT")), mode, kTRUE))return kFALSE;
1772    }
1773    if(iPWG4TmpSourceSara){
1774      if(!kUsePAR)gSystem->AddIncludePath("-I$ALICE_ROOT/include/JetTasks"); // ugly hack!!
1775      if(!LoadSource(Form("%s/PWG4/JetTasks/AliAnalysisTaskEta.cxx",gSystem->ExpandPathName("$ALICE_ROOT")), mode, kTRUE))return kFALSE;
1776    }
1777
1778    if (iPWG4PartCorrLibs) {
1779       if (!LoadLibrary("PWG4PartCorrBase", mode, kTRUE) ||
1780           !LoadLibrary("PWG4PartCorrDep", mode, kTRUE)) return kFALSE;
1781    }
1782    if(iPWG4JCORRAN){
1783      // PWG4 particle correlations
1784      if(!LoadLibrary("PWG4JCORRAN",mode,kTRUE))return kFALSE;
1785    }
1786    if (iPWG4JetCorr) {
1787      if (!LoadLibrary("PWG4JetCorrel", mode, kTRUE)) return kFALSE;
1788    }
1789    if (iPWG4omega3pi) {
1790      if (!LoadLibrary("PWG4omega3pi", mode, kTRUE)) return kFALSE;
1791    }
1792    if (iPWG4GammaConvLib) {
1793       if (!LoadLibrary("PWG4GammaConv", mode, kTRUE)) return kFALSE;
1794    }
1795
1796    ::Info("AnalysisTrainPWG4Jets.C::LoadAnalysisLibraries", "Load other libraries:   SUCCESS");
1797    return kTRUE;
1798 }
1799
1800 //______________________________________________________________________________
1801 Bool_t LoadLibrary(const char *module, const char *mode, Bool_t rec=kFALSE)
1802 {
1803 // Load a module library in a given mode. Reports success.
1804    Int_t imode = -1;
1805    Int_t result;
1806    TString smodule(module);
1807    if (!strcmp(mode, "LOCAL")) imode = 0;
1808    if (!strcmp(mode, "PROOF")) imode = 1;
1809    if (!strcmp(mode, "GRID"))  imode = 2;
1810    TString mod(module);
1811    if (!mod.Length()) {
1812       ::Error("AnalysisTrainPWG4Jets.C::LoadLibrary", "Empty module name");
1813       return kFALSE;
1814    }
1815    // If a library is specified, just load it
1816    if (smodule.EndsWith(".so")) {
1817       mod.Remove(mod.Index(".so"));
1818       result = gSystem->Load(mod);
1819       if (result < 0) {
1820          ::Error("AnalysisTrainPWG4Jets.C::LoadLibrary", "Could not load library %s", module);
1821          return kFALSE;
1822       }
1823       if (rec) anaLibs += Form("%s.so ",mod.Data());
1824       if (rec) anaLibsExtra += Form("%s.so ",mod.Data());
1825       return kTRUE;
1826    }
1827    // Check if the library is already loaded
1828    if (strlen(gSystem->GetLibraries(Form("%s.so", module), "", kFALSE)) > 0)
1829       return kTRUE;
1830    switch (imode) {
1831       case 0:
1832       case 2:
1833          if (kUsePAR) {
1834             result = SetupPar(module);
1835             if (rec) anaPars += Form("%s.par ", module);
1836          } else {
1837             result = gSystem->Load(Form("lib%s.so", module));
1838             if (rec) anaLibs += Form("lib%s.so ", module);
1839          }
1840          break;
1841       case 1:
1842         if(!gSystem->AccessPathName(module)){
1843           ::Info("AnalysisTrainPWG4Jets.C::LoadLibrary", "Removing directory %s",module);
1844           gSystem->Exec(Form("rm -rf %s",module));
1845         }
1846          result = gProof->UploadPackage(module);
1847          if (result<0) {
1848             result = gProof->UploadPackage(gSystem->ExpandPathName(Form("$ALICE_ROOT/%s.par", module)));
1849             if (result<0) {
1850                ::Error("AnalysisTrainPWG4Jets.C::LoadLibrary", "Could not find module %s.par in current directory nor in $ALICE_ROOT", module);
1851                return kFALSE;
1852             }
1853          }
1854          result = gProof->EnablePackage(module);
1855          break;
1856       default:
1857          return kFALSE;
1858    }
1859    if (result < 0) {
1860       ::Error("AnalysisTrainPWG4Jets.C::LoadLibrary", "Could not load module %s", module);
1861       return kFALSE;
1862    }
1863    return kTRUE;
1864 }
1865
1866
1867
1868 //______________________________________________________________________________
1869 Bool_t LoadSource(const char *source, const char *mode, Bool_t rec=kFALSE)
1870 {
1871 // Load a module library in a given mode. Reports success.
1872    Int_t imode = -1;
1873    Int_t result = -1;
1874    if (!strcmp(mode, "LOCAL")) imode = 0;
1875    if (!strcmp(mode, "PROOF")) imode = 1;
1876    if (!strcmp(mode, "GRID"))  imode = 2;
1877    TString ssource(source);
1878    TString basename = gSystem->BaseName(ssource.Data());
1879    if (!ssource.Length()) {
1880       ::Error("AnalysisTrainPWG4Jets.C::LoadSource", "Empty task name");
1881       return kFALSE;
1882    }
1883    // we have a source code so compile it
1884    if (ssource.EndsWith(".cxx")) {
1885      // need to copy it here other wise the path is also used on grid...
1886      ssource.Remove(ssource.Index(".cxx"));
1887      basename.Remove(basename.Index(".cxx"));
1888      Printf("LoadSources:: Copying...  path %s{cxx,h}",ssource.Data());
1889      gSystem->Exec(Form("cp %s.cxx . ",ssource.Data()));
1890      gSystem->Exec(Form("cp %s.h . ",ssource.Data()));
1891      // Path to code
1892      // only needed for local compilation, in grid and proof mode
1893      // the task headers are uploaded
1894      //     path.Remove(path.Index(gSystem->BaseName(path.Data())));
1895      // Printf("LoadSources:: Including path %s",path.Data());
1896      //  if(path.Length()>0)gROOT->ProcessLine(Form(".include %s",path.Data()));
1897      Printf("LoadSources:: Loading...  path %s",basename.Data());
1898      switch (imode) {
1899      case 0:
1900        result = gROOT->LoadMacro(Form("%s.cxx++g",basename.Data()));
1901        break;
1902      case 1:
1903        result = gProof->LoadMacro(Form("%s.cxx++g",basename.Data()));
1904        break;
1905      case 2:
1906        result = gROOT->LoadMacro(Form("%s.cxx++g",basename.Data()));
1907        if (rec){
1908          // what we want to compile
1909          anaSources += Form("%s.cxx ",basename.Data());
1910          // what we need as input...
1911          anaLibs += Form("%s.cxx %s.h ",basename.Data(),basename.Data());
1912        }
1913        break;
1914      default:
1915        return kFALSE;
1916      }
1917    }
1918    if (result < 0) {
1919       ::Error("AnalysisTrainPWG4Jets.C::LoadSources", "Could not load source %s", source);
1920       return kFALSE;
1921    }
1922    return kTRUE;
1923 }
1924
1925
1926 //______________________________________________________________________________
1927 TChain *CreateChain(const char *mode, const char *plugin_mode)
1928 {
1929 // Create the input chain
1930    Int_t imode = -1;
1931    if (!strcmp(mode, "LOCAL")) imode = 0;
1932    if (!strcmp(mode, "PROOF")) imode = 1;
1933    if (!strcmp(mode, "GRID"))  imode = 2;
1934    TChain *chain = NULL;
1935    // Local chain
1936    switch (imode) {
1937       case 0:
1938          if (iAODanalysis) {
1939             if (!kLocalXMLDataset.Length()) {
1940                // Local AOD
1941                chain = new TChain("aodTree");
1942                TString line;
1943                ifstream in;
1944                in.open(kLocalDataList.Data());
1945                Int_t ic = 0;
1946                while (in.good()) {
1947                  in >> line;
1948                  if (line.Length() == 0) continue;
1949                  Printf("%d adding %s",ic,line.Data());
1950                  chain->Add(line.Data());
1951                  ic++;
1952                }
1953             } else {
1954                // Interactive AOD
1955                chain = CreateChainSingle(kLocalXMLDataset, "aodTree");
1956             }
1957          } else {
1958            if (!kLocalXMLDataset.Length()) {
1959              // Local ESD
1960              chain = new TChain("esdTree");
1961              TString line;
1962              ifstream in;
1963              in.open(kLocalDataList.Data());
1964              while (in.good()) {
1965                in >> line;
1966                if (line.Length() == 0) continue;
1967                cout << " line = " << line << endl;
1968                chain->Add(line.Data());
1969              }
1970            } else {
1971              // Interactive ESD
1972                chain = CreateChainSingle(kLocalXMLDataset, "esdTree");
1973            }
1974          }
1975          break;
1976       case 1:
1977          break;
1978       case 2:
1979          if (kPluginUse) {
1980 //            AliAnalysisGrid *alienHandler = CreateAlienHandler(plugin_mode);
1981 //            AliAnalysisManager::GetAnalysisManager()->SetGridHandler(alienHandler);
1982          } else {
1983             TString           treeName = "esdTree";
1984             if (iAODanalysis) treeName = "aodTree";
1985             chain = CreateChainSingle("wn.xml", treeName);
1986          }
1987          break;
1988       default:
1989    }
1990    if (chain && chain->GetNtrees()) return chain;
1991    return NULL;
1992 }
1993
1994 //______________________________________________________________________________
1995 TChain* CreateChainSingle(const char* xmlfile, const char *treeName)
1996 {
1997    printf("*******************************\n");
1998    printf("*** Getting the ESD Chain   ***\n");
1999    printf("*******************************\n");
2000    TAlienCollection * myCollection  = TAlienCollection::Open(xmlfile);
2001
2002    if (!myCollection) {
2003       ::Error("AnalysisTrainPWG4Jets.C::CreateChainSingle", "Cannot create an AliEn collection from %s", xmlfile) ;
2004       return NULL ;
2005    }
2006
2007    TChain* chain = new TChain(treeName);
2008    myCollection->Reset() ;
2009    while ( myCollection->Next() ) chain->Add(myCollection->GetTURL("")) ;
2010    chain->ls();
2011    return chain;
2012 }
2013
2014 //______________________________________________________________________________
2015 Int_t SetupPar(char* pararchivename)
2016 {
2017    if (!pararchivename || !strlen(pararchivename)) return -1;
2018    char processline[1024];
2019    if (gSystem->AccessPathName(Form("%s.par", pararchivename))) {
2020       if (!gSystem->AccessPathName(Form("%s/%s.par", gSystem->Getenv("ALICE_ROOT"),pararchivename))) {
2021          ::Info("AnalysisTrainPWG4Jets.C::SetupPar", "Getting %s.par from $ALICE_ROOT", pararchivename);
2022         TFile::Cp(gSystem->ExpandPathName(Form("$ALICE_ROOT/%s.par", pararchivename)),
2023                   Form("%s.par",pararchivename));
2024       } else {
2025          ::Error("AnalysisTrainPWG4Jets.C::SetupPar", "Cannot find %s.par", pararchivename);
2026          return -1;
2027       }
2028    }
2029    if (kPluginUse && kSaveTrain) gSystem->Exec(Form("ln -s ../%s.par %s",pararchivename, kTrainName.Data()));
2030    gSystem->Exec(Form("tar xvzf %s.par", pararchivename));
2031
2032    TString ocwd = gSystem->WorkingDirectory();
2033    if (!gSystem->ChangeDirectory(pararchivename)) return -1;
2034
2035    // check for BUILD.sh and execute
2036    if (!gSystem->AccessPathName("PROOF-INF/BUILD.sh")) {
2037       printf("*******************************\n");
2038       printf("*** Building PAR archive    ***\n");
2039       printf("*******************************\n");
2040       if (gSystem->Exec("PROOF-INF/BUILD.sh")) {
2041          Error("runProcess","Cannot Build the PAR Archive! - Abort!");
2042          return -1;
2043       }
2044    }
2045
2046         // check for SETUP.C and execute
2047         if (!gSystem->AccessPathName("PROOF-INF/SETUP.C")) {
2048             printf("*******************************\n");
2049             printf("*** Setup PAR archive       ***\n");
2050             printf("*******************************\n");
2051             gROOT->Macro("PROOF-INF/SETUP.C");
2052         }
2053         if (!gSystem->ChangeDirectory(ocwd.Data())){
2054           Error("Change back directory",Form("Cannot change to %s",ocwd.Data()));
2055           return -1;
2056         }
2057    return 0;
2058 }
2059
2060 //______________________________________________________________________________
2061 AliAnalysisAlien* CreateAlienHandler(const char *plugin_mode)
2062 {
2063 // Check if user has a valid token, otherwise make one. This has limitations.
2064 // One can always follow the standard procedure of calling alien-token-init then
2065 //   source /tmp/gclient_env_$UID in the current shell.
2066 //   if (!AliAnalysisGrid::CreateToken()) return NULL;
2067    AliAnalysisAlien *plugin = new AliAnalysisAlien();
2068 // Set the run mode (can be "full", "test", "offline", "submit" or "terminate")
2069    plugin->SetRunMode(plugin_mode);
2070    if (kPluginUseProductionMode) plugin->SetProductionMode();
2071    plugin->SetJobTag(kJobTag);
2072    plugin->SetNtestFiles(1);
2073 //   plugin->SetPreferedSE("ALICE::NIHAM::File");
2074 // Set versions of used packages
2075    plugin->SetAPIVersion("V1.1x");
2076    //   plugin->SetAPIVersion("V1.0x");
2077 //   plugin->SetAPIVersion("V2.4");
2078    plugin->SetROOTVersion(kPluginRootVersion);
2079    plugin->SetAliROOTVersion(kPluginAliRootVersion);
2080 // Declare input data to be processed.
2081 // Method 1: Create automatically XML collections using alien 'find' command.
2082 // Define production directory LFN
2083    plugin->SetGridDataDir(kGridDatadir.Data());
2084 // Set data search pattern
2085    if (iAODanalysis) plugin->SetDataPattern(Form(" %s/*/*AliAOD.root",kGridPassPattern.Data()));
2086    else              plugin->SetDataPattern(Form(" %s/*/*AliESDs.root",kGridPassPattern.Data()));
2087 // ...then add run numbers to be considered
2088 //   plugin->SetRunRange(kGridRunRange[0], kGridRunRange[1]);
2089    for (Int_t i=kGridRunRange[0]; i<=kGridRunRange[1]; i++) {
2090      Printf("AnalysisTrainPWG4Jets Adding run number %s", Form(kGridRunPattern.Data(),i));
2091      plugin->AddRunNumber(Form(kGridRunPattern.Data(),i));
2092    }
2093
2094    if(kGridLocalRunList.Length()>0){
2095      ifstream in1;
2096      in1.open(kGridLocalRunList.Data());
2097      int iRun;
2098      int icount = 0;
2099      Int_t nRun = 0;
2100      // just use run numbers, negatives will be excluded
2101      while(in1>>iRun){
2102        if(iRun>=0){
2103          if(iRun>=0&&nRun>=kGridOffsetRunFromList&&(nRun<kGridMaxRunsFromList)){
2104            Printf("AnalysisTrainPWG4Jets Adding run number from File %d: %s",nRun,Form(kGridRunPattern.Data(),iRun));
2105            plugin->AddRunNumber(Form(kGridRunPattern.Data(),iRun));
2106
2107          }
2108          else{
2109            Printf("AnalysisTrainPWG4Jets Skipping run number from File %d: %d",nRun, iRun);
2110          }
2111          nRun++;
2112        }
2113        else{
2114          Printf("AnalysisTrainPWG4Jets Skipping run number from File %d: %d",nRun, iRun);
2115        }
2116      }
2117    }
2118 // Method 2: Declare existing data files (raw collections, xml collections, root file)
2119 // If no path mentioned data is supposed to be in the work directory (see SetGridWorkingDir())
2120 // XML collections added via this method can be combined with the first method if
2121 // the content is compatible (using or not tags)
2122 //   plugin->AddDataFile("tag.xml");
2123 //   plugin->AddDataFile("/alice/data/2008/LHC08c/000057657/raw/Run57657.Merged.RAW.tag.root");
2124 // Define alien work directory where all files will be copied. Relative to alien $HOME.
2125    TString alien_workdir = "";
2126
2127    if (iAODanalysis)  alien_workdir += "analysisAOD";
2128    else               alien_workdir += "analysisESD";
2129        if(kGridDataSet.Length()>0)alien_workdir += Form("/%s%s",kGridDataSet.Data(),kGridExtraAliendirLevel.Data());
2130    plugin->SetGridWorkingDir(alien_workdir.Data());
2131
2132    // Declare alien output directory. Relative to working directory.
2133    if (!kGridOutdir.Length()) kGridOutdir = Form("output_%s",kTrainName.Data());
2134    plugin->SetGridOutputDir(kGridOutdir);
2135
2136    // Add external packages
2137    plugin->AddExternalPackage("boost::v1_43_0");
2138    plugin->AddExternalPackage("cgal::v3.6");
2139    plugin->AddExternalPackage("fastjet::v2.4.2");
2140
2141
2142    // set extra libs before par file compilation
2143    anaLibs += kGridExtraFiles;
2144    anaLibs     = anaLibs.Strip();
2145    Printf("anaLibs %s",anaLibs.Data());
2146    Printf("anaLibsExtra %s",anaLibsExtra.Data());
2147
2148    if (anaLibs.Length())          plugin->SetAdditionalLibs(anaLibs.Data());
2149    if (anaLibsExtra.Length())     plugin->SetAdditionalRootLibs(anaLibsExtra.Data());
2150
2151    TString ana_sources = "";
2152    TString ana_add = "";
2153    if (kUsePAR && anaPars.Length()) {
2154       printf("%s\n", anaPars.Data());
2155       TObjArray *arr;
2156       TObjString *objstr;
2157       arr = anaPars.Tokenize(" ");
2158       TIter next(arr);
2159       while ((objstr=(TObjString*)next())) plugin->EnablePackage(objstr->GetString());
2160       delete arr;
2161    }
2162
2163 // Declare the analysis source files names separated by blancs. To be compiled runtime
2164 // using ACLiC on the worker nodes.
2165    ana_sources = anaSources.Strip();
2166 // Declare all libraries (other than the default ones for the framework. These will be
2167 // loaded by the generated analysis macro. Add all extra files (task .cxx/.h) here.
2168
2169    if (ana_sources.Length()) plugin->SetAnalysisSource(ana_sources);
2170    plugin->SetExecutableCommand(kPluginExecutableCommand.Data());
2171    // Declare the output file names separated by blancs.
2172    // (can be like: file.root or file.root@ALICE::Niham::File)
2173    plugin->SetMergeExcludes(kGridMergeExclude);
2174    plugin->SetMaxMergeFiles(kGridMaxMergeFiles);
2175    plugin->SetNrunsPerMaster(kGridRunsPerMaster);
2176    plugin->SetMergeViaJDL(kPluginMergeViaJDL);
2177    // Use fastread option
2178    plugin->SetFastReadOption(kPluginFastReadOption);
2179    // UseOverwrite mode
2180    plugin->SetOverwriteMode(kPluginOverwriteMode);
2181    // Optionally define the files to be archived.
2182    //   plugin->SetOutputArchive("log_archive.zip:stdout,stderr@ALICE::NIHAM::File root_archive.zip:AliAOD.root,AOD.tag.root@ALICE::NIHAM::File");
2183    plugin->SetOutputToRunNo(kPluginOutputToRunNumber);     // write the output to subdirs named after run number
2184
2185    // Put default output files to archive
2186    TString listhists = "";
2187    TString listaods  = "";
2188    AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
2189    TIter next(mgr->GetOutputs());
2190    AliAnalysisDataContainer *output;
2191    while ((output=(AliAnalysisDataContainer*)next())) {
2192       const char *filename = output->GetFileName();
2193       if (!(strcmp(filename, "default"))) {
2194         if (!mgr->GetOutputEventHandler()) continue;
2195          filename = mgr->GetOutputEventHandler()->GetOutputFileName();
2196          if (listaods.Length()) listaods += " ";
2197          listaods += filename;
2198       } else {
2199         if(!listhists.Contains(filename)){
2200           if (listhists.Length()) listhists += " ";
2201           listhists += filename;
2202         }
2203       }
2204    }
2205
2206    if (mgr->GetExtraFiles().Length()) {
2207      if (listaods.Length()) listaods += " ";
2208      listaods += mgr->GetExtraFiles();
2209    }
2210
2211    // if we do not fill the aod we do not need to store it
2212    //   kGridMergeExclude = listaods;
2213
2214    if(kSaveAOD>=0){
2215      TString outputFiles =  "";
2216      outputFiles += mgr->GetExtraFiles();
2217      if (listhists.Length()) outputFiles += " ";
2218      outputFiles += listhists;
2219      plugin->SetDefaultOutputs(kFALSE);
2220      Printf("%s:%d Starting with the files %s",(char*)__FILE__,__LINE__,outputFiles.Data());
2221      // remove
2222      // no harm done when we try to remove something that is not there :)
2223      if(!(kSaveAOD&(1<<0))){
2224        outputFiles.ReplaceAll("AliAOD.root ","");
2225        listaods.ReplaceAll("AliAOD.root ","");
2226      }
2227      if(!(kSaveAOD&(1<<1))){
2228        if(kDeltaAODJetName.Length())outputFiles.ReplaceAll(kDeltaAODJetName.Data(),"");
2229        if(kDeltaAODJetName.Length())listaods.ReplaceAll(kDeltaAODJetName.Data(),"");
2230
2231      }
2232      if(!(kSaveAOD&(1<<2))){
2233        if(kDeltaAODPartCorrName.Length())outputFiles.ReplaceAll(kDeltaAODPartCorrName.Data(),"");
2234        if(kDeltaAODPartCorrName.Length())listaods.ReplaceAll(kDeltaAODPartCorrName.Data(),"");
2235      }
2236      if(!(kSaveAOD&(1<<3))){
2237        if(kDeltaAODJCORRANName.Length())outputFiles.ReplaceAll(kDeltaAODJCORRANName.Data(),"");
2238        if(kDeltaAODJCORRANName.Length())listaods.ReplaceAll(kDeltaAODJCORRANName.Data(),"");
2239      }
2240
2241      //
2242      plugin->SetDefaultOutputs(kFALSE);
2243      Printf("%s:%d Saving the files %s",(char*)__FILE__,__LINE__,outputFiles.Data());
2244      plugin->SetOutputFiles(outputFiles.Data());
2245    }
2246
2247    TString outputArchive;
2248    outputArchive = Form("log_archive.zip:std*@%s","disk=1");
2249    listaods.ReplaceAll(" ", ",");
2250    listhists.ReplaceAll(" ", ",");
2251    if (listhists.Length()){
2252      outputArchive += " ";
2253      outputArchive += "root_archive.zip:";
2254      outputArchive += listhists;
2255      if (listaods.Length()){
2256        outputArchive += ",";
2257        outputArchive += listaods;
2258      }
2259      outputArchive += Form("@%s", kGridOutputStorages.Data());
2260    }
2261    else{
2262
2263      if (listaods.Length()){
2264        // we have only aod'ish output
2265        outputArchive += " ";
2266        outputArchive += "root_archive.zip:";
2267        outputArchive += listaods;
2268        outputArchive += Form("@%s", kGridOutputStorages.Data());
2269      }
2270      else{
2271        // no other outputs than std..
2272       ::Fatal("AnalysisTrainPWG4Jets", "No task output !");
2273      }
2274    }
2275
2276    plugin->SetDefaultOutputs(kFALSE);
2277    plugin->SetOutputArchive(outputArchive);
2278
2279
2280    // Optionally set a name for the generated analysis macro (default MyAnalysis.C)
2281    plugin->SetAnalysisMacro(Form("%s.C", kTrainName.Data()));
2282    // Optionally set maximum number of input files/subjob (default 100, put 0 to ignore)
2283    plugin->SetSplitMaxInputFileNumber(kGridFilesPerJob);
2284    // Optionally set number of failed jobs that will trigger killing waiting sub-jobs.
2285    //   plugin->SetMaxInitFailed(5);
2286    // Optionally resubmit threshold.
2287    // plugin->SetMasterResubmitThreshold(90);
2288    // Optionally set time to live (default 30000 sec)
2289    plugin->SetTTL(80000); // 22h...
2290    // Optionally set input format (default xml-single)
2291    plugin->SetInputFormat("xml-single");
2292    // Optionally modify the name of the generated JDL (default analysis.jdl)
2293    plugin->SetJDLName(Form("%s.jdl", kTrainName.Data()));
2294    // Optionally modify the executable name (default analysis.sh)
2295    plugin->SetExecutable(Form("%s.sh", kTrainName.Data()));
2296    // Optionally modify job price (default 1)
2297    plugin->SetPrice(1);
2298    // Optionally modify split mode (default 'se')
2299    plugin->SetSplitMode("se");
2300    return plugin;
2301 }
2302
2303 //______________________________________________________________________________
2304 void WriteConfig()
2305 {
2306 // Write train configuration in a file. The file name has the format:
2307 // train_[trainName]_ddMonthyyyy_time.C
2308    if (kUseDate) {
2309       gSystem->Exec("date +%d%b%Y_%Hh%M > date.tmp");
2310       ifstream fdate("date.tmp");
2311       if (!fdate.is_open()) {
2312          ::Error("AnalysisTrainPWG4Jets.C::Export","Could not generate file name");
2313          return;
2314       }
2315       const char date[64];
2316       fdate.getline(date,64);
2317       fdate.close();
2318       gSystem->Exec("rm date.tmp");
2319       kTrainName = Form("train_%s_%s", kTrainName.Data(), date);
2320    } else {
2321       kTrainName = Form("train_%s", kTrainName.Data());
2322    }
2323    TString cdir = gSystem->WorkingDirectory();
2324    gSystem->MakeDirectory(kTrainName);
2325    gSystem->ChangeDirectory(kTrainName);
2326    ofstream out;
2327    out.open(Form("%sConfig.C",kTrainName.Data()), ios::out);
2328    if (out.bad()) {
2329       ::Error("AnalysisTrainPWG4Jets.C::Export", "Cannot open ConfigTrain.C for writing");
2330       return;
2331    }
2332    out << "{" << endl;
2333    out << "   kTrainName      = " << "\"" << kTrainName.Data() << "\";" << endl;
2334    out << "   kProofCluster   = " << "\"" << kProofCluster.Data() << "\";" << endl;
2335    out << "   kProofUseAFPAR        = " << kProofUseAFPAR << ";" << endl;
2336    if (kProofUseAFPAR)
2337       out << "   kProofAFversion       = " << kProofAFversion.Data() << ";" << endl;
2338    out << "   kProofDataSet   = " << "\"" << kProofDataSet.Data() << "\";" << endl;
2339    out << "   kPluginUse       = " << kPluginUse << ";" << endl;
2340    out << "   kUsePAR          = " << kUsePAR << ";" << endl;
2341    out << "   kUseCPAR         = " << kUseCPAR << ";" << endl;
2342    out << "   kPluginRootVersion    = " << "\"" << kPluginRootVersion.Data() << "\";" << endl;
2343    out << "   kPluginAliRootVersion = " << "\"" << kPluginAliRootVersion.Data() << "\";" << endl;
2344    out << "   kGridDatadir   = " << "\"" << kGridDatadir.Data() << "\";" << endl;
2345    if (!kGridOutdir.Length()) kGridOutdir = Form("output_%s",kTrainName.Data());
2346    out << "   kGridOutdir    = " << "\"" << kGridOutdir.Data() << "\";" << endl;
2347    out << "   kGridMaxMergeFiles   = " << kGridMaxMergeFiles << ";" << endl;
2348    out << "   kGridMergeExclude    = " << "\"" << kGridMergeExclude.Data() << "\";" << endl;
2349    out << "   kGridRunsPerMaster  = " << kGridRunsPerMaster << ";" << endl;
2350    out << "   kGridFilesPerJob    = " << kGridFilesPerJob << ";" << endl;
2351    out << "   kGridRunRange[0]    = " << kGridRunRange[0] << ";" << endl;
2352    out << "   kGridRunRange[1]    = " << kGridRunRange[1] << ";" << endl;
2353    out << "   kUseDebug          = " << kUseDebug << ";" << endl;
2354    out << "   kUseMC           = " << kUseMC << ";" << endl;
2355    out << "   kUseESDTags         = " << kUseESDTags << ";" << endl;
2356    out << "   kUseKinefilter      = " << kUseKinefilter << ";" << endl;
2357    out << "   kUseTR           = " << kUseTR << ";" << endl;
2358    out << "   kUseAODTags      = " << kUseAODTags << ";" << endl;
2359    out << "   kSaveTrain       = " << "kFALSE;" << endl << endl;
2360    out << "   // Analysis modules" << endl;
2361    out << "   iAODanalysis    = " << iAODanalysis << ";" << endl;
2362    out << "   iAODhandler     = " << iAODhandler << ";" << endl;
2363    out << "   iESDfilter      = " << iESDfilter << ";" << endl;
2364    out << "   iJETAN          = " << iJETAN << ";" << endl;
2365    out << "// Configuration fot the wagons" << endl;
2366    out << "}" << endl;
2367    ::Info("AnalysisTrainPWG4Jets.C::WriteConfig", "Train configuration wrote to file %s", Form("config_%s.C", kTrainName.Data()));
2368    gSystem->ChangeDirectory(cdir);
2369 }
2370
2371 //______________________________________________________________________________
2372 Bool_t LoadConfig(const char *filename)
2373 {
2374 // Read train configuration from file
2375    if (gSystem->AccessPathName(filename)) {
2376       ::Error("AnalysisTrainPWG4Jets.C::LoadConfig", "Config file name not found");
2377       return kFALSE;
2378    }
2379    gROOT->ProcessLine(Form(".x %s", filename));
2380    ::Info("AnalysisTrainPWG4Jets.C::LoadConfig", "Train configuration loaded from file %s", filename);
2381    return kTRUE;
2382 }
2383
2384 Bool_t PatchJDL(){
2385   Printf(">>> Patching JDL");
2386   AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
2387   AliAnalysisAlien*    gridHandler = (AliAnalysisAlien*)mgr->GetGridHandler();
2388   TGridJDL *jdl = gridHandler->GetGridJDL();
2389   if(iJETAN)jdl->AddToPackages("fastjet","v2.4.0");
2390   gridHandler->WriteJDL(kFALSE);
2391   Printf("<<<  Patching JDL");
2392   return kTRUE;
2393 }
2394
2395 Bool_t PatchAnalysisMacro(){
2396   Printf(">>> Patching AnalysisMacro");
2397   gSystem->Exec(Form("mv %s.C %s.C_tmp",kTrainName.Data(),kTrainName.Data()));
2398
2399   ifstream in1;
2400   in1.open(Form("%s.C_tmp", kTrainName.Data()));
2401   char cLine[250];
2402   TString st;
2403   while(in1.getline(cLine,250)){
2404     st += cLine;
2405     st += "\n";
2406   }
2407   Int_t index= -1;
2408   index = st.Index("gSystem->Load(\"libPhysics\");");
2409   index += strlen("gSystem->Load(\"libPhysics\");");
2410   /*
2411     TObjArray *arr;
2412     TObjString *objstr;
2413     arr = anaLibs.Tokenize(" ");
2414     TIter next(arr);
2415
2416     add += "\n\n // added by CKB \n";
2417     while ((objstr=(TObjString*)next())){
2418       if(objstr->GetString().Contains("PWG3"))continue;
2419       if(objstr->GetString().EndsWith(".so"))add += Form("gSystem->Load(\"%s\");\n",objstr->GetString().Data());
2420     }
2421     delete arr;
2422     */
2423     //    add += Form("AliLog::SetGlobalLogLevel(%d);\n",AliLog::GetGlobalLogLevel());
2424   TString add = "";
2425
2426   if(index<0)Printf("%s:%d index out of bounds",(char*)__FILE__,__LINE__);
2427   add += "\n\n // added by CKB \n";
2428   if(kErrorIgnoreLevel>0)add += Form("gErrorIgnoreLevel = %d;\n",kErrorIgnoreLevel);
2429   add += "\n gSystem->AddIncludePath(\"./\"); \n";
2430   add += "\n gSystem->SetFPEMask(); \n";
2431
2432
2433   if(gGrid&&kPluginAliRootVersion.Length()==0){
2434     /*
2435     add += "\n // Dirty hack for TRD reference data \n";
2436     add += "\n gSystem->Setenv(\"ALICE_ROOT\",\"";
2437     add += Form("alien://%s/rootfiles/",gGrid->GetHomeDirectory());
2438     add += "\"); \n";
2439     */
2440   }
2441
2442   add += "// BKC \n\n";
2443   st.Insert(index,add.Data());
2444
2445   if(kUseDebug){
2446     //    st.Insert(index,"\n gROOT->ProcessLine(\".trace\"); // CKB \n");
2447   }
2448
2449   if(kUseCPAR&&kPluginAliRootVersion.Length()==0){
2450     index = st.Index("gSystem->AddIncludePath(\"-I$"); // uncommen $ALICE_ROOT include for par files
2451     if(index<0)Printf("%s:%d index out of bounds",(char*)__FILE__,__LINE__);
2452     st.Insert(index,"// CKB comment out whehn no aliroot is provided \n //");
2453   }
2454
2455   if(AliLog::GetGlobalLogLevel()==AliLog::kFatal){
2456     index = st.Index("AliLog::SetGlobal"); // ncomment setting of log level, do my own
2457     if(index<0)Printf("%s:%d index out of bounds",(char*)__FILE__,__LINE__);
2458     st.Insert(index,"AliLog::SetGlobalLogLevel(AliLog::kFatal);// CKB \n  // CKB comment out for own setting \n  //");
2459   }
2460
2461   ofstream out;
2462   out.open(Form("%s.C", kTrainName.Data()));
2463   if (out.bad()) {
2464     return kFALSE;
2465   }
2466   out << st << endl;
2467   Printf("<<< Patching AnalysisMacro");
2468
2469
2470
2471
2472
2473   Printf(">>> Patching Merge Macro");
2474   gSystem->Exec(Form("mv %s_merge.C %s_merge.C_tmp",kTrainName.Data(),kTrainName.Data()));
2475
2476   ifstream in2;
2477   in2.open(Form("%s_merge.C_tmp", kTrainName.Data()));
2478   TString st2;
2479   while(in2.getline(cLine,250)){
2480     st2 += cLine;
2481     st2 += "\n";
2482   }
2483   index = st2.Index("gSystem->Load(\"libPhysics\");");
2484   index += strlen("gSystem->Load(\"libPhysics\");");
2485   TString add2 = "";
2486   add2 += "\n gSystem->AddIncludePath(\"./\"); \n";
2487   if(gGrid&&kPluginAliRootVersion.Length()==0){
2488     /*
2489     add2 += "\n // Dirty hack for TRD reference data \n";
2490     add2 += "\n gSystem->Setenv(\"ALICE_ROOT\",\"";
2491     add2 += Form("alien://%s/rootfiles/",gGrid->GetHomeDirectory());
2492     add2 += "\"); \n";
2493     */
2494   }
2495   add2 += "// BKC \n\n";
2496   if(index<0)Printf("%s:%d index out of bounds",(char*)__FILE__,__LINE__);
2497   st2.Insert(index,add.Data());
2498
2499
2500   if(kUseDebug){
2501     //    st2.Insert(index,"\n gROOT->ProcessLine(\".trace\"); // CKB \n");
2502   }
2503
2504   if(kUseCPAR&&kPluginAliRootVersion.Length()==0){
2505     index = st2.Index("gSystem->AddIncludePath(\"-I$"); // uncomment $ALICE_ROOT include for par files
2506     if(index<0)Printf("%s:%d index out of bounds",(char*)__FILE__,__LINE__);
2507     st2.Insert(index,"// CKB comment out whehn no aliroot is provided \n //");
2508   }
2509
2510   // do not exclude the extra files from merign, this is done explicitly in this train script
2511   //  index = st2.Index("mergeExcludes +="); // uncommen $ALICE_ROOT include for par files
2512   //  if(index<0)Printf("%s:%d index out of bounds",(char*)__FILE__,__LINE__);
2513   // st2.Insert(index,"// CKB comment out, handled explicitly by the train macro \n //");
2514
2515
2516   ofstream out2;
2517   out2.open(Form("%s_merge.C", kTrainName.Data()));
2518   if (out2.bad()) {
2519     return kFALSE;
2520   }
2521   out2 << st2 << endl;
2522   Printf("<<< Patching Merging Macro");
2523
2524
2525
2526   return kTRUE;
2527
2528 }