X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=PWG4%2Fmacros%2FAnalysisTrainPWG4Jets.C;h=1035dc970289be4937bfd5ccdb7051d9f63ea65a;hb=c8fb37dd688774c45a50f9ea94ea17f65d66d193;hp=e4f43ed3e182bcf4b367924373a5771dc7d9c67e;hpb=3878a9415dd2c21bd941186e612678776df0f421;p=u%2Fmrichter%2FAliRoot.git diff --git a/PWG4/macros/AnalysisTrainPWG4Jets.C b/PWG4/macros/AnalysisTrainPWG4Jets.C index e4f43ed3e18..1035dc97028 100644 --- a/PWG4/macros/AnalysisTrainPWG4Jets.C +++ b/PWG4/macros/AnalysisTrainPWG4Jets.C @@ -32,8 +32,9 @@ TString kJobTag = "PWG4 Jet Tasks analysis train configured"; // Bool_t kUsePAR = kFALSE; // use par files for extra libs Bool_t kUseCPAR = kFALSE; // use par files for common libs Bool_t kFillAOD = kFALSE; // switch of AOD filling for on the fly analysis - +Int_t kSaveAOD = 8; // Bit switch 1 = Full AOD 2 = Jet AOD , 4 = PartCorr, 8 = JCORRAN //== general input and output variables + Int_t iAODanalysis = 1; // Analysis on input AOD's Int_t iAODhandler = 1; // Analysis produces an AOD or dAOD's Int_t iESDfilter = 0; // ESD to AOD filter (barrel + muon tracks) @@ -41,15 +42,28 @@ Int_t iPhysicsSelection = 1; // ESD to AOD filter (barrel + muon tra Bool_t kUseKinefilter = kFALSE; // use Kinematics filter Bool_t kUseMuonfilter = kFALSE; // use Kinematics filter TString kCommonOutputFileName = "PWG4_JetTasksOutput.root"; +TString kCaloQAOutputFileName = "PWG4_CaloQAOutput.root"; //== general process variables // ### Other flags to steer the analysis //============================================================================== +Bool_t kSkipTerminate = kTRUE; // Do not call Teminate Bool_t kUseDate = kFALSE; // use date in train name Bool_t kUseDebug = kTRUE; // activate debugging -Int_t kUseSysInfo = 0; // activate debugging +Int_t kErrorIgnoreLevel = -1; // takes the errror print level from .rootrc +// From TError.h: +// const Int_t kUnset = -1; +// const Int_t kPrint = 0; +// const Int_t kInfo = 1000; +// const Int_t kWarning = 2000; +// const Int_t kError = 3000; +// const Int_t kBreak = 4000; +// const Int_t kSysError = 5000; +// const Int_t kFatal = 6000; +Int_t kUseSysInfo = 0; // activate debugging +Long64_t kNumberOfEvents = 1234567890; // number of events to process from the chain Bool_t kUseMC = kTRUE; // use MC info Bool_t kIsMC = kTRUE; // is MC info, if false it overwrites Use(AOD)MC Bool_t kUseAODMC = kTRUE; // use MC infA @@ -58,6 +72,7 @@ Bool_t kUseTR = kFALSE; // use track references Bool_t kUseAODTags = kFALSE; // use AOD tags Bool_t kSaveTrain = kFALSE; // save train configuration as: + // ### Analysis modules to be included. Some may not be yet fully implemented. //============================================================================== Int_t iJETAN = 1; // Jet analysis (PWG4) // 1 write standard 2 write non-standard jets, 3 wrtie both @@ -67,23 +82,33 @@ Int_t iPWG1QASym = 0; // Eva's QA task compiled on the fly... Int_t iPWG4JetTasks = 0; // all jet tasks flag for lib laoding Int_t iPWG4JetServices = 0; // jet spectrum analysis Int_t iPWG4JetSpectrum = 0; // jet spectrum analysis +Int_t iPWG4JCORRAN = 0; // JCORRAN module Int_t iPWG4UE = 0; // Underlying Event analysis -Int_t iPWG4TmpSourceSara = 0; // Underlying Event analysis +Int_t iPWG4LeadingUE = 0; // Underlying Event analysis +Int_t iPWG4CorrectionsUE = 0; // Underlying Event analysis +Int_t iPWG4TmpSourceSara = 0; // Underlying Event analysis not in svn +Int_t iPWG4Fragmentation = 0; // Official Fragmentation +Int_t iPWG4JetChem = 0; // Jet chemistry Int_t iPWG4PtQAMC = 0; // Marta's QA tasks Int_t iPWG4PtSpectra = 0; // Marta's QA tasks Int_t iPWG4PtQATPC = 0; // Marta's QA tasks +Int_t iPWG4Cosmics = 0; // Marta's Cosmics Taks Int_t iPWG4ThreeJets = 0; // Sona's thrust task Int_t iPWG4KMeans = 0; // Andreas' KMeans task Int_t iPWG4Cluster = 0; // CKB cluster task +Int_t iEMCUtilLibs = 0; // Flag to satisfy dependence on EMC utils Int_t iPWG4PartCorrLibs = 0; // Gustavo's part corr analysis Int_t iPWG4PartCorr = 0; // Gustavo's part corr analysis Int_t iPWG4CaloQA = 0; // Gustavo's part corr analysis Int_t iPWG4JetCorr = 0; // Paul's jet corr analysis Int_t iPWG4Tagged = 0; // Gustavo's part corr analysis Int_t iPWG4omega3pi = 0; // Omega to 3 pi analysis (PWG4) +Int_t iPWG4GammaConvLib = 0; // Gamma Conversio Int_t iPWG4GammaConv = 0; // Gamma Conversio +Int_t iPWG4CaloConv = 0; // Gamma Conversio Int_t kHighPtFilterMask = 16; // change depending on the used AOD Filter TString kDeltaAODJetName = "AliAOD.Jets.root"; +TString kDeltaAODJCORRANName = "AliAOD.JCORRAN.root"; TString kDeltaAODPartCorrName = "deltaAODPartCorr.root"; @@ -110,22 +135,28 @@ Int_t kProofOffset = 0; //== grid plugin setup variables Bool_t kPluginUse = kTRUE; // do not change Bool_t kPluginUseProductionMode = kFALSE; // use the plugin in production mode -TString kPluginRootVersion = "v5-26-00b-1"; // *CHANGE ME IF MORE RECENT IN GRID* -TString kPluginAliRootVersion = "v4-19-04-AN"; // *CHANGE ME IF MORE RECENT IN GRID* +TString kPluginRootVersion = "v5-27-05"; // *CHANGE ME IF MORE RECENT IN GRID* +TString kPluginAliRootVersion = "v4-19-15-AN"; // *CHANGE ME IF MORE RECENT IN GRID* +Bool_t kPluginMergeViaJDL = kTRUE; // merge via JDL +Bool_t kPluginFastReadOption = kFALSE; // use xrootd tweaks +Bool_t kPluginOverwriteMode = kTRUE; // overwrite existing collections +Int_t kPluginOutputToRunNumber = 1; // write the output to subdirs named after run number // TString kPluginExecutableCommand = "root -b -q"; TString kPluginExecutableCommand = "source /Users/kleinb/setup_32bit_aliroot_trunk_clean_root_trunk.sh; alienroot -b -q "; + // == grid plugin input and output variables TString kGridDatadir = "/alice/sim/PDC_08b/LHC09a1/AOD/"; +Int_t kGridMaxRunsFromList = 999999999; TString kGridLocalRunList = ""; TString kGridOutdir = ""; // AliEn output directory. If blank will become output_ TString kGridDataSet = ""; // sub working directory not to confuse different run xmls -Int_t kGridRunRange[2] = {0, -1}; // Set the run range +Int_t kGridRunRange[2] = {0, -1}; // Set the run range TString kGridRunPattern = "%03d"; // important for leading zeroes!! TString kGridPassPattern = ""; TString kGridExtraFiles = ""; // files that will be added to the input list in the JDL... -Int_t kGridMaxMergeFiles = 50; // Number of files merged in a chunkgridrunragn +Int_t kGridMaxMergeFiles = 12; // Number of files merged in a chunk grid run range TString kGridMergeExclude = "AliAOD.root"; // Files that should not be merged -TString kGridOutputStorages = "ALICE::NIHAM::File,ALICE::CNAF::SE,ALICE::FZK::SE,ALICE::GSI::SE,ALICE::Legnaro::SE"; // Make replicas on the storages +TString kGridOutputStorages = "disk=2"; // Make replicas on the storages // == grid process variables Int_t kGridRunsPerMaster = 100; // Number of runs per master job Int_t kGridFilesPerJob = 100; // Maximum number of files per job (gives size of AOD) @@ -165,47 +196,57 @@ void AnalysisTrainPWG4Jets(const char *analysis_mode="local", if (kSaveTrain)WriteConfig(); // Check compatibility of selected modules CheckModuleFlags(smode); - // gROOT->ProcessLine(".trace"); + // gROOT->ProcessLine(".trace"); printf("==================================================================\n"); printf("=========== RUNNING ANALYSIS TRAIN %s IN %s MODE ==========\n", kTrainName.Data(),smode.Data()); printf("==================================================================\n"); - printf("= Configuring analysis train for: =\n"); + printf("= Configuring analysis train for: =\n"); if (iAODanalysis) printf("= AOD analysis =\n"); - else printf("= ESD analysis =\n"); - if (iPhysicsSelection) printf("= Physics selection =\n"); + else printf("= ESD analysis =\n"); + if (iPhysicsSelection) printf("= Physics selection =\n"); if (iESDfilter) printf("= ESD filter =\n"); if (iJETAN) printf("= Jet analysis =\n"); printf("==================================================================\n"); - printf(":: use Fill AOD %d\n", (UInt_t)kFillAOD); - printf(":: use MC truth %d\n", (UInt_t)kUseMC); - printf(":: use KINE filter %d\n", (UInt_t)kUseKinefilter); - printf(":: use track refs %d\n", (UInt_t)kUseTR); - printf(":: use tags %d\n", (UInt_t)kUseESDTags); - printf(":: use AOD tags %d\n", (UInt_t)kUseAODTags); - printf(":: use debugging %d\n", (UInt_t)kUseDebug); - printf(":: use PAR files %d\n", (UInt_t)kUsePAR); - printf(":: use AliEn plugin %d\n", (UInt_t)kPluginUse); - printf(":: use PWG1 QA sym %d\n", iPWG1QASym); - printf(":: use PWG4 Source Sara %d\n",iPWG4TmpSourceSara); - printf(":: use PWG4 Jet tasks %d\n",iPWG4JetTasks); - printf(":: use PWG4 Jet Services %d\n",iPWG4JetServices); - printf(":: use PWG4 Jet Spectrum %d\n",iPWG4JetSpectrum); - printf(":: use PWG4 UE %d \n",iPWG4UE); - printf(":: use PWG4 Pt QA MC %d\n",iPWG4PtQAMC); - printf(":: use PWG4 Pt Spectra %d\n",iPWG4PtSpectra); - printf(":: use PWG4 Pt QA TPC %d\n",iPWG4PtQATPC); - printf(":: use PWG4 Three Jets %d\n",iPWG4ThreeJets); - printf(":: use PWG4 KMeans %d\n",iPWG4KMeans); - printf(":: use PWG4 Cluster %d\n",iPWG4Cluster); - printf(":: use PWG4 Part Corr %d\n",iPWG4PartCorr); - printf(":: use PWG4 Calo QA %d\n",iPWG4CaloQA); - printf(":: use PWG4 Jet Corr %d\n",iPWG4JetCorr); - printf(":: use PWG4 Tagged %d\n",iPWG4Tagged); - printf(":: use PWG4 omega to 3 pions %d\n",iPWG4omega3pi); - - printf(":: use PWG4 Gamma Conv %d\n",iPWG4GammaConv); - printf(":: use HighPt FilterMask %d\n",kHighPtFilterMask); + + char *printMask = ":: %20s %10d\n"; + printf(printMask,"Fill AOD",(UInt_t)kFillAOD); + printf(printMask,"Save AOD", (UInt_t)kSaveAOD); + printf(printMask,"MC truth", (UInt_t)kUseMC); + printf(printMask,"KINE filter", (UInt_t)kUseKinefilter); + printf(printMask,"track refs", (UInt_t)kUseTR); + printf(printMask,"tags", (UInt_t)kUseESDTags); + printf(printMask,"AOD tags", (UInt_t)kUseAODTags); + printf(printMask,"debugging", (UInt_t)kUseDebug); + printf(printMask,"PAR files", (UInt_t)kUsePAR); + printf(printMask,"AliEn plugin", (UInt_t)kPluginUse); + printf(printMask,"PWG1 QA sym", iPWG1QASym); + printf(printMask,"PWG4 Source Sara",iPWG4TmpSourceSara); + printf(printMask,"PWG4 Fragmentation",iPWG4Fragmentation); + printf(printMask,"PWG4 Jet Chem",iPWG4JetChem); + printf(printMask,"PWG4 Jet tasks",iPWG4JetTasks); + printf(printMask,"PWG4 Jet Services",iPWG4JetServices); + printf(printMask,"PWG4 Jet Spectrum",iPWG4JetSpectrum); + printf(printMask,"PWG4 JCORRAN",iPWG4JCORRAN); + printf(printMask,"PWG4 UE",iPWG4UE); + printf(printMask,"PWG4 Leading UE",iPWG4LeadingUE); + printf(printMask,"PWG4 Corrections UE",iPWG4CorrectionsUE); + printf(printMask,"PWG4 Pt QA MC",iPWG4PtQAMC); + printf(printMask,"PWG4 Pt Spectra",iPWG4PtSpectra); + printf(printMask,"PWG4 Pt QA TPC",iPWG4PtQATPC); + printf(printMask,"PWG4 Cosmics",iPWG4Cosmics); + printf(printMask,"PWG4 Three Jets",iPWG4ThreeJets); + printf(printMask,"PWG4 KMeans",iPWG4KMeans); + printf(printMask,"PWG4 Cluster",iPWG4Cluster); + printf(printMask,"PWG4 Part Corr",iPWG4PartCorr); + printf(printMask,"PWG4 Calo QA",iPWG4CaloQA); + printf(printMask,"PWG4 Jet Corr",iPWG4JetCorr); + printf(printMask,"PWG4 JCORRAN",iPWG4JCORRAN); + printf(printMask,"PWG4 Tagged",iPWG4Tagged); + printf(printMask,"PWG4 omega to 3 pi ",iPWG4omega3pi); + printf(printMask,"PWG4 Gamma Conv",iPWG4GammaConv); + printf(printMask,"PWG4 Calo Conv",iPWG4CaloConv); + printf(printMask,"HighPt FilterMask",kHighPtFilterMask); //========================================================================== // Connect to back-end system @@ -226,8 +267,11 @@ void AnalysisTrainPWG4Jets(const char *analysis_mode="local", AliAnalysisManager *mgr = new AliAnalysisManager("PWG4Train", "pwg4 mini train"); if (kCommonOutputFileName.Length()>0)mgr->SetCommonFileName(kCommonOutputFileName.Data()); if (kProofSaveToAlien) mgr->SetSpecialOutputLocation(kProofOutdir); + mgr->SetNSysInfo(0); if (!strcmp(plugin_mode, "test")) mgr->SetNSysInfo(1); if (kUseSysInfo)mgr->SetNSysInfo(kUseSysInfo); + mgr->SetSkipTerminate(kSkipTerminate); + // Load analysis specific libraries if (!LoadAnalysisLibraries(smode)) { ::Error("AnalysisTrain", "Could not load analysis libraries"); @@ -245,8 +289,10 @@ void AnalysisTrainPWG4Jets(const char *analysis_mode="local", // ESD input handler AliESDInputHandler *esdHandler = new AliESDInputHandler(); if (kUseESDTags) esdHandler->SetReadTags(); + esdHandler->SetReadFriends(kFALSE); mgr->SetInputEventHandler(esdHandler); - if(iPWG4PtQATPC)esdHandler->SetActiveBranches("ESDfriend"); + // if(iPWG4PtQATPC&& !kTrainName.Contains("pass5"))esdHandler->SetActiveBranches("ESDfriend"); + } // Monte Carlo handler @@ -260,7 +306,7 @@ void AnalysisTrainPWG4Jets(const char *analysis_mode="local", // AOD output handler AliAODHandler* aodHandler = new AliAODHandler(); aodHandler->SetOutputFileName("AliAOD.root"); - aodHandler->SetFillAOD(kFillAOD); + aodHandler->SetFillAODforRun(kFillAOD); mgr->SetOutputEventHandler(aodHandler); // @@ -273,11 +319,20 @@ void AnalysisTrainPWG4Jets(const char *analysis_mode="local", cout_aod->SetSpecialOutput(); } // Debugging if needed + if (kUseDebug){ mgr->SetDebugLevel(3); } - mgr->SetDebugLevel(0); - AliLog::SetGlobalLogLevel(AliLog::kError); + if(kUseSysInfo>0){ + mgr->RegisterExtraFile("syswatch.root"); + if(kGridMergeExclude.Length())kGridMergeExclude += " "; + kGridMergeExclude += "syswatch.root"; + } + else{ + AliLog::SetGlobalLogLevel(AliLog::kError); + } + + //========================================================================== // Create the chain. In this example it is created only from ALIEN files but // can be done to work in batch or grid mode as well. @@ -293,13 +348,20 @@ void AnalysisTrainPWG4Jets(const char *analysis_mode="local", // from each task configuration macro. if(iPhysicsSelection && !iAODanalysis){ gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C"); - AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(kIsMC,kTRUE); + AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(kIsMC,kTRUE,kTRUE); // last flag also adds information on } if (iESDfilter && !iAODanalysis) { // ESD filter task configuration. - gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskESDFilter.C"); + gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskESDFilterPWG4Train.C"); AliAnalysisTaskESDfilter *taskesdfilter = AddTaskESDFilter(kUseKinefilter,kUseMuonfilter); + taskesdfilter->SetEnableFillAOD(kFALSE); + if(kIsMC){ + mgr->RegisterExtraFile("pyxsec_hists.root"); + if(kGridMergeExclude.Length())kGridMergeExclude += " "; + kGridMergeExclude += "pyxsec_hists.root"; + + } } // AOD tags @@ -319,22 +381,64 @@ void AnalysisTrainPWG4Jets(const char *analysis_mode="local", if(iJETAN&1)taskjets = AddTaskJets(kHighPtFilterMask); if(iJETAN&2){ UInt_t selection = 0; - if(!kFillAOD) selection = 0xffffff; //&~(1<<13); - else selection = 1<<0|1<<1|1<<2|1<<3|1<<4|1<<5|1<<6|1<<7|1<<8|1<<9; + if(!kFillAOD){ + selection = 0xffffff&~(1<<13)&~(1<<5)&~(1<<6); // switch OFF DA and all R = 0.7 to save processing time + selection &= ~(1<<1)&~(1<<2)&~(1<<4)&~(1<<6)&~(1<<8)&~(1<<10)&~(1<<12); + } + else { + selection = 0xffffff&~(1<<13)&~(1<<5)&~(1<<6); // switch OFF DA and all R = 0.7 to save processing time; + selection &= ~(1<<1)&~(1<<2)&~(1<<4)&~(1<<6)&~(1<<8)&~(1<<10)&~(1<<12); + } AddTaskJetsDelta(kDeltaAODJetName.Data(),kHighPtFilterMask,kUseAODMC,selection); + AddTaskJets("AOD","FASTKT",0.2,kHighPtFilterMask); } if (!taskjets) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskJets cannot run for this train conditions - EXCLUDED"); } + if(iPWG4Cluster){ + gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJetCluster.C"); + AliAnalysisTaskJetCluster *taskCl = 0; + if(iPWG4Cluster&1){ + taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelection,"KT"); + if (!taskCl) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskCluster cannot run for this train conditions - EXCLUDED"); + } + if(iPWG4Cluster&2){ + UInt_t selection = 0; + if(!iAODanalysis) selection = 0xffffff; + else selection = 1<<0|1<<1|1<<2|1<<3|1<<4|1<<5|1<<7|1<<8|1<<9; + selection&=~(1<<4); // exluded R = .04 already the dafault + AddTaskJetClusterDelta(kHighPtFilterMask,kUseAODMC,iPhysicsSelection,"KT",selection); + } + if(iPWG4Cluster&4){ + UInt_t selection = 0; + if(!iAODanalysis){ + selection = 0xffffff; + selection &= ~(1<<1)&~(1<<3)&~(1<<5)&~(1<<7)&~(1<<9); + } + else selection = 1<<0|1<<1|1<<2|1<<3|1<<4|1<<5|1<<7|1<<8|1<<9; + AddTaskJetClusterDelta(kHighPtFilterMask,kUseAODMC,iPhysicsSelection,"ANTIKT",selection); + AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelection,"ANTIKT",0.4,1); + + } + } + if (iDIJETAN) { gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskDiJets.C"); AliAnalysisTaskDiJets *taskdijets = 0; - taskdijets = AddTaskDiJets(); + if(iDIJETAN&1)taskdijets = AddTaskDiJets(); if (!taskdijets) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskJets cannot run for this train conditions - EXCLUDED"); + if(iDIJETAN&2){ + taskdijets = AddTaskDiJets("jetsAOD_CDF07"); + taskdijets = AddTaskDiJets("jetsAOD_DA07"); + taskdijets = AddTaskDiJets("jetsAOD_FASTJET07"); + taskdijets = AddTaskDiJets("jetsAOD_FASTKT07"); + taskdijets = AddTaskDiJets("jetsAOD_SISCONE07"); + taskdijets = AddTaskDiJets("jetsAOD_UA107"); + } } if(iPWG1QASym){ - gROOT->LoadMacro("$ALICE_ROOT/prod/acrcaf/qa_pp/AddTaskQAsym.C"); + gROOT->LoadMacro("$ALICE_ROOT/PWG1/PilotTrain/AddTaskQAsym.C"); AliAnalysisTaskQASym *taskQASym = AddTaskQAsym(-1); if (!taskQASym) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskQASym cannot run for this train conditions - EXCLUDED"); } @@ -347,73 +451,144 @@ void AnalysisTrainPWG4Jets(const char *analysis_mode="local", if (!taskEta) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskEta cannot run for this train conditions - EXCLUDED"); } + if(iPWG4Fragmentation){ + gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskFragmentationFunction.C"); + AliAnalysisTaskFragmentationFunction *taskFrag = 0; + if(kUseAODMC){ + taskFrag = AddTaskFragmentationFunction(1<<1,kHighPtFilterMask); + taskFrag = AddTaskFragmentationFunction(1<<2,kHighPtFilterMask); + taskFrag = AddTaskFragmentationFunction(1<<3,kHighPtFilterMask); + taskFrag = AddTaskFragmentationFunction(1<<11); // w/o acceptance cuts + taskFrag = AddTaskFragmentationFunction(1<<12); // with acceptance cuts + // anti-kt + taskFrag = AddTaskFragmentationFunction(1<<21); // w/o acceptance cuts + taskFrag = AddTaskFragmentationFunction(1<<22); // with acceptance cuts + + } + else{ + taskFrag = AddTaskFragmentationFunction(1<<0,kHighPtFilterMask); + taskFrag = AddTaskFragmentationFunction(1<<10,kHighPtFilterMask); + taskFrag = AddTaskFragmentationFunction(1<<20,kHighPtFilterMask); + } + + if (!taskFrag) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskFragmentationFunction cannot run for this train conditions - EXCLUDED"); + } + + + if(iPWG4JetChem){ + gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJetChem.C"); + AliAnalysisTask *taskChem = AddTaskJetChem(); + if (!taskChem) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskJetChem cannot run for this train conditions - EXCLUDED"); + } + + if(iPWG4JetServices){ gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJetServices.C"); AliAnalysisTaskJetServices *taskjetServ = 0; taskjetServ = AddTaskJetServices(); if (!taskjetServ) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskJetServices cannot run for this train conditions - EXCLUDED"); if(kGridRunRange[0]>0)taskjetServ->SetRunRange(kGridRunRange[0],kGridRunRange[1]); - else taskjetServ->SetRunRange(104000,105000); + else taskjetServ->SetRunRange(100000,150000); if(!kIsMC) taskjetServ->SetRealData(kTRUE); - if(!iPhysicsSelection)taskjetServ->SetUsePhysicsSelection(kFALSE); + taskjetServ->SetUsePhysicsSelection((Bool_t)iPhysicsSelection); + taskjetServ->SetDebugLevel(0); } if(iPWG4JetSpectrum){ gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJetSpectrum2.C"); AliAnalysisTaskJetSpectrum2 *taskjetSpectrum = 0; if(iPWG4JetSpectrum&1){ - taskjetSpectrum = AddTaskJetSpectrum2("jets","",kHighPtFilterMask,iPhysicsSelection); + taskjetSpectrum = AddTaskJetSpectrum2("jets","","",kHighPtFilterMask,iPhysicsSelection); if(!iAODanalysis){ - taskjetSpectrum = AddTaskJetSpectrum2("jets","tracks32",32,iPhysicsSelection); // tmp hack to give it a different name - taskjetSpectrum = AddTaskJetSpectrum2("jets","tracks64",64,iPhysicsSelection); + // taskjetSpectrum = AddTaskJetSpectrum2("jets","tracks32",32,iPhysicsSelection); // tmp hack to give it a different name + // taskjetSpectrum = AddTaskJetSpectrum2("jets","64",64,iPhysicsSelection); + + taskjetSpectrum = AddTaskJetSpectrum2("jetsAOD_FASTJET04","clustersAOD_ANTIKT04","",kHighPtFilterMask,iPhysicsSelection); + + if(kIsMC){ + + UInt_t eventSelection = AliAnalysisHelperJetTasks::kIsPileUp|AliAnalysisHelperJetTasks::kVertexIn; + if(iPhysicsSelection)eventSelection |= AliAnalysisHelperJetTasks::kPhysicsSelection; + taskjetSpectrum = AddTaskJetSpectrum2("jetsAOD_FASTJET04","jetsAODMC_FASTJET04","",kHighPtFilterMask,iPhysicsSelection,eventSelection); + taskjetSpectrum = AddTaskJetSpectrum2("jetsAOD_FASTJET04","jetsAODMC2_FASTJET04","",kHighPtFilterMask,iPhysicsSelection,eventSelection); + + eventSelection = AliAnalysisHelperJetTasks::kIsCosmic|AliAnalysisHelperJetTasks::kVertexIn; + if(iPhysicsSelection)eventSelection |= AliAnalysisHelperJetTasks::kPhysicsSelection; + taskjetSpectrum = AddTaskJetSpectrum2("jetsAOD_FASTJET04","jetsAODMC_FASTJET04","",kHighPtFilterMask,iPhysicsSelection,eventSelection); + + eventSelection = AliAnalysisHelperJetTasks::kNone; + taskjetSpectrum = AddTaskJetSpectrum2("jetsAOD_FASTJET04","jetsAODMC2_FASTJET04","",kHighPtFilterMask,iPhysicsSelection,eventSelection); + taskjetSpectrum = AddTaskJetSpectrum2("jetsAOD_FASTJET04","jetsAODMC_FASTJET04","",kHighPtFilterMask,iPhysicsSelection,eventSelection); + + } + else{ + UInt_t eventSelection = AliAnalysisHelperJetTasks::kIsPileUp|AliAnalysisHelperJetTasks::kVertexIn; + if(iPhysicsSelection)eventSelection |= AliAnalysisHelperJetTasks::kPhysicsSelection; + taskjetSpectrum = AddTaskJetSpectrum2("jetsAOD_FASTJET04","","",kHighPtFilterMask,iPhysicsSelection,eventSelection); + + eventSelection = AliAnalysisHelperJetTasks::kIsCosmic|AliAnalysisHelperJetTasks::kVertexIn; + if(iPhysicsSelection)eventSelection |= AliAnalysisHelperJetTasks::kPhysicsSelection; + taskjetSpectrum = AddTaskJetSpectrum2("jetsAOD_FASTJET04","","",kHighPtFilterMask,iPhysicsSelection,eventSelection); + } } if (!taskjetSpectrum) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskJetSpectrum2 cannot run for this train conditions - EXCLUDED"); - taskjetSpectrum->SetDebugLevel(1); + // taskjetSpectrum->SetDebugLevel(1); } if(iPWG4JetSpectrum&2){ UInt_t selection = 0; - if(!iAODanalysis) selection = 0xffffff; + if(!iAODanalysis){ + selection = 0xffffff; + // switch off 07 radii + selection &= ~(1<<6)&~(1<<11)&~(1<<12)&~(1<<13)&~(1<<14); + } else selection = 1<<0|1<<1|1<<2|1<<3|1<<4|1<<5|1<<7|1<<8|1<<9; - AddTaskJetSpectrum2Delta(kHighPtFilterMask,kUseAODMC,iPhysicsSelection,selection); + AddTaskJetSpectrum2Delta(kHighPtFilterMask,kUseAODMC,iPhysicsSelection,selection,0,kTRUE); } - if(iJETAN&3&&!kFillAOD&!iAODanalysis){ - AddTaskJetSpectrum2("jetsAOD_FASTKT00","",kHighPtFilterMask,iPhysicsSelection); - AddTaskJetSpectrum2("jetsAOD_FASTKT01","",kHighPtFilterMask,iPhysicsSelection); - AddTaskJetSpectrum2("jetsAOD_FASTKT02","",kHighPtFilterMask,iPhysicsSelection); - AddTaskJetSpectrum2("jetsAOD_FASTKT06","",kHighPtFilterMask,iPhysicsSelection); - AddTaskJetSpectrum2("jetsAOD_FASTKT08","",kHighPtFilterMask,iPhysicsSelection); - if(kIsMC){ - AddTaskJetSpectrum2("jetsAODMC2b_FASTKT00","",kHighPtFilterMask,iPhysicsSelection); - AddTaskJetSpectrum2("jetsAODMC2b_FASTKT01","",kHighPtFilterMask,iPhysicsSelection); - AddTaskJetSpectrum2("jetsAODMC2b_FASTKT02","",kHighPtFilterMask,iPhysicsSelection); - AddTaskJetSpectrum2("jetsAODMC2b_FASTKT06","",kHighPtFilterMask,iPhysicsSelection); - AddTaskJetSpectrum2("jetsAODMC2b_FASTKT08","",kHighPtFilterMask,iPhysicsSelection); - } + } + if(iPWG4JCORRAN){ + gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJCORRANTask.C"); + AliJCORRANTask* corran = AddTaskJCORRAN(kDeltaAODJCORRANName.Data(),0); + if(!corran)::Warning("AnalysisTrainPWG4Jets", "AliJCORRANTask cannot run for this train conditions - EXCLUDED"); + else{ + if(kDeltaAODJCORRANName.Length()>0)mgr->RegisterExtraFile(kDeltaAODJCORRANName.Data()); } } + if(iPWG4UE){ gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskUE.C"); AliAnalysisTaskUE *taskUE = 0; if(iPWG4UE&1)taskUE = AddTaskUE(); if(iPWG4UE&2){ - taskUE = AddTaskUE("jetsAOD_CDF07","CDF","LJ","TRANSV"); - taskUE = AddTaskUE("jetsAOD_UA1LO07","CDF","LJ","TRANSV"); - taskUE = AddTaskUE("jetsAOD_UA1LO07","CDF","BB","TRANSV"); - taskUE = AddTaskUE("jetsAOD_FASTKT04","CDF","LJ","TRANSV"); - taskUE = AddTaskUE("jetsAOD_FASTJET04","CDF","LJ","TRANSV"); - taskUE = AddTaskUE("jetsAOD_SISCONE04","CDF","LJ","TRANSV"); - taskUE = AddTaskUE("jetsAOD_CDF07","ALICE","LJ","TRANSV"); - taskUE = AddTaskUE("jetsAOD_UA1LO07","ALICE","LJ","TRANSV"); - taskUE = AddTaskUE("jetsAOD_UA1LO07","ALICE","BB","TRANSV"); - taskUE = AddTaskUE("jetsAOD_FASTKT04","ALICE","LJ","TRANSV"); - taskUE = AddTaskUE("jetsAOD_FASTJET04","ALICE","LJ","TRANSV"); - taskUE = AddTaskUE("jetsAOD_SISCONE04","ALICE","LJ","TRANSV"); + taskUE =AddTaskUE("jetsAOD_CDF04","CDF", "LJ", "TRANSV","MSP"); //finder not yet in train + // taskUE =AddTaskUE("jetsAOD_CDF07","CDF", "LJ", "TRANSV","MSP"); + taskUE =AddTaskUE("jetsAOD_SISCONE04","CDF", "LJ", "TRANSV","MSP"); + // taskUE =AddTaskUE("jetsAOD_SISCONE07","CDF", "LJ", "TRANSV","MSP"); //finder not yet in train + taskUE =AddTaskUE("jetsAOD_ICDF","CDF","LJ","TRANSV","MSP"); + taskUE =AddTaskUE("jetsAOD_FASTKT04","CDF", "LJ", "TRANSV","MSP"); + // taskUE =AddTaskUE("jetsAOD_FASTKT07","CDF", "LJ", "TRANSV","MSP"); //finder not yet in train + taskUE =AddTaskUE("jetsAOD_NONE","CDF", "MP_eta05", "TRANSV","MSP"); + taskUE =AddTaskUE("jetsAOD_NONE","CDF", "MP_eta09", "TRANSV","MSP"); } if (!taskUE) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskUE cannot run for this train conditions - EXCLUDED"); } + if(iPWG4LeadingUE){ + gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskLeadingTrackUE.C"); + AliAnalysisTaskLeadingTrackUE *taskLeadingUE = AddTaskLeadingTrackUE(kUseMC); + if (!taskLeadingUE) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTasLeadingTrackkUE cannot run for this train conditions - EXCLUDED"); + taskLeadingUE->SetFilterBit(64); + } + + + if(iPWG4CorrectionsUE){ + gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskCorrectionsUE.C"); + AliAnalysisTaskCorrectionsUE *taskCorrectionsUE = 0; + if(iPWG4CorrectionsUE&1)taskCorrectionsUE = AddTaskCorrectionsUE("jetsAOD_NONE","CDF","MP_eta05","TRANSV","MSP",kFALSE); + if (!taskCorrectionsUE) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskCorrectionsUE cannot run for this train conditions - EXCLUDED"); + } + if(iPWG4ThreeJets){ gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskThreeJets.C"); AliAnalysisTaskThreeJets *taskThree = AddTaskThreeJets(); @@ -421,19 +596,32 @@ void AnalysisTrainPWG4Jets(const char *analysis_mode="local", } if(iPWG4PtQAMC){ gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskPWG4HighPtQAMC.C"); - AliPWG4HighPtQAMC *taskQAMC = AddTaskPWG4HighPtQAMC(); + AliPWG4HighPtQAMC *taskQAMC = AddTaskPWG4HighPtQAMC(kGridDataSet.Data()); if (!taskQAMC) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskQAMC cannot run for this train conditions - EXCLUDED"); } if(iPWG4PtQATPC){ gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskPWG4HighPtQATPConly.C"); - AliPWG4HighPtQATPConly *taskQATPC = AddTaskPWG4HighPtQATPConly(); - if (!taskQATPC) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskQATPC cannot run for this train conditions - EXCLUDED"); + AliPWG4HighPtQATPConly *taskQATPC = 0; + if(iPWG4PtQATPC&1)taskQATPC = AddTaskPWG4HighPtQATPConly(kGridDataSet.Data(),1); + if(iPWG4PtQATPC&2)taskQATPC = AddTaskPWG4HighPtQATPConly(kGridDataSet.Data(),2); + + if (!taskQATPC) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskQATPC cannot run for this train conditions - EXCLUDED"); + } + + if(iPWG4Cosmics){ + gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskPWG4CosmicCandidates.C"); + + AliPWG4CosmicCandidates *taskPWG4CosmicCandidates = AddTaskPWG4CosmicCandidates(0); + taskPWG4CosmicCandidates = AddTaskPWG4CosmicCandidates(1); + + if (!taskPWG4CosmicCandidates) ::Warning("AnalysisTrainPWG4Jets", "AddTaskPWG4CosmicCandidates cannot run for this train conditions - EXCLUDED"); } + if(iPWG4PtSpectra){ gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskPWG4HighPtSpectra.C"); - AliPWG4HighPtSpectra *taskPtSpectra = AddTaskPWG4HighPtSpectra(); + AliPWG4HighPtSpectra *taskPtSpectra = AddTaskPWG4HighPtSpectra(kGridDataSet.Data()); if (!taskPtSpectra) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskPtSpectra cannot run for this train conditions - EXCLUDED"); } if(iPWG4KMeans){ @@ -442,46 +630,36 @@ void AnalysisTrainPWG4Jets(const char *analysis_mode="local", if (!taskKMeans) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskKMenans cannot run for this train conditions - EXCLUDED"); } - if(iPWG4Cluster){ - gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJetCluster.C"); - AliAnalysisTaskJetCluster *taskCl = 0; - if(iPWG4Cluster&1)taskCl = AddTaskJetCluster("AOD","",kHighPtFilterMask,iPhysicsSelection); - if(iPWG4Cluster&2){ - UInt_t selection = 0; - if(!iAODanalysis) selection = 0xffffff; - else selection = 1<<0|1<<1|1<<2|1<<3|1<<4|1<<5|1<<7|1<<8|1<<9; - AddTaskJetClusterDelta(kHighPtFilterMask,kUseAODMC,iPhysicsSelection,selection); - } - if (!taskCl) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskCluster cannot run for this train conditions - EXCLUDED"); - - } if(iPWG4PartCorr){ gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskPartCorr.C"); AliAnalysisTaskParticleCorrelation *taskpartcorrPHOS = AddTaskPartCorr("AOD", "PHOS",kFALSE,kIsMC); if (!taskpartcorrPHOS) ::Warning("AnalysisTrainNew", "AliAnalysisTaskParticleCorrelation PHOS cannot run for this train conditions - EXCLUDED"); AliAnalysisTaskParticleCorrelation *taskpartcorrEMCAL = AddTaskPartCorr("AOD", "EMCAL",kFALSE,kIsMC); if (!taskpartcorrEMCAL) ::Warning("AnalysisTrainNew", "AliAnalysisTaskParticleCorrelation EMCAL cannot run for this train conditions - EXCLUDED"); - if(kDeltaAODPartCorrName.Length()>0)mgr->RegisterExtraFile(kDeltaAODPartCorrName.Data()); // hmm this is written anyway.... but at least we do not register it... + if(kDeltaAODPartCorrName.Length()>0)mgr->RegisterExtraFile(kDeltaAODPartCorrName.Data()); } if(iPWG4CaloQA){ gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/QA/AddTaskCalorimeterQA.C"); - AliAnalysisTaskParticleCorrelation *taskcaloQA = AddTaskCalorimeterQA("ESD",kFALSE,kIsMC); + AliAnalysisTaskParticleCorrelation *taskcaloQA = AddTaskCalorimeterQA("ESD",kFALSE,kIsMC,kCaloQAOutputFileName.Data()); if(!taskcaloQA)::Warning("AnalysisTrainNew", "AliAnalysisTaskParticleCorrelation QA cannot run - EXCLUDED"); + // if(kCaloQAOutputFileName.Length()>0)mgr->RegisterExtraFile(kCaloQAOutputFileName.Data()); } if(iPWG4JetCorr){ // using namespace JetCorrelHD; - + TString cdir = gSystem->WorkingDirectory(); + gSystem->ChangeDirectory(gSystem->ExpandPathName("$ALICE_ROOT/PWG4/macros/")); gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJetCorrel.C"); AliAnalysisTaskJetCorrel *taskjetcorr = AddTaskJetCorrel(); - if (!taskpartcorrEMCAL) ::Warning("AnalysisTrainNew", "AliAnalysisTaskJetCorrel cannot run for this train conditions - EXCLUDED"); + gSystem->ChangeDirectory(cdir); + if (!taskjetcorr) ::Warning("AnalysisTrainNew", "AliAnalysisTaskJetCorrel cannot run for this train conditions - EXCLUDED"); } if(iPWG4Tagged){ gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskTaggedPhotons.C"); AliAnalysisTaskTaggedPhotons * taskTagged = AddTaskTaggedPhotons(kFALSE); // EMCAL - // taskTagged = AddTaskTaggedPhotons(kTRUE); // PHOS + taskTagged = AddTaskTaggedPhotons(kTRUE); // PHOS if (!taskTagged) ::Warning("AnalysisTrainNew", "AliAnalysisTaskTaggedPhotons cannot run for this train conditions - EXCLUDED"); } if (iPWG4omega3pi) { @@ -497,7 +675,11 @@ void AnalysisTrainPWG4Jets(const char *analysis_mode="local", TString cdir = gSystem->WorkingDirectory(); gSystem->ChangeDirectory(gSystem->ExpandPathName("$ALICE_ROOT/PWG4/macros/")); // TString gcArguments = "-run-on-train -run-jet -run-chic -run-neutralmeson -run-cf"; - TString gcArguments = "-run-on-train -run-jet -run-neutralmeson -run-cf -use-own-xyz -bg-off"; + // TString gcArguments = "-run-on-train -run-jet -run-neutralmeson -run-cf -use-own-xyz"; + // TString gcArguments = "-run-on-train -run-jet -run-neutralmeson -run-cf -use-own-xyz"; + TString gcArguments = "-run-on-train -run-jet -run-omega-meson -use-own-xyz -run-neutralmeson -no-aod"; + TString kGCAnalysisCutSelectionId="900356200010031"; + gcArguments.Append(Form(" -set-cut-selection %s ",kGCAnalysisCutSelectionId.Data())); if(!kIsMC)gcArguments += " -mc-off"; AliAnalysisTaskGammaConversion * taskGammaConversion = AddTaskGammaConversion(gcArguments,mgr->GetCommonInputContainer()); gSystem->ChangeDirectory(cdir); @@ -505,6 +687,13 @@ void AnalysisTrainPWG4Jets(const char *analysis_mode="local", if (!taskGammaConversion) ::Warning("AnalysisTrainNew", "AliAnalysisTaskGammaConversion cannot run for these train conditions - EXCLUDED"); } + if (iPWG4CaloConv) { + gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskCaloConv.C"); + AliAnalysisTaskCaloConv * taskCaloConv = AddTaskCaloConv(); + if (!taskCaloConv) ::Warning("AnalysisTrainNew", "AliAnalysisTaskCaloConv cannot run for these train conditions - EXCLUDED"); + } + + //========================================================================== // FOR THE REST OF THE TASKS THE MACRO AddTaskXXX() is not yet implemented/ @@ -526,11 +715,49 @@ void AnalysisTrainPWG4Jets(const char *analysis_mode="local", AliAnalysisAlien *gridhandler = (AliAnalysisAlien*)mgr->GetGridHandler(); printf("=== AnalysisTrainPWG4Jets:: Registering jdl in the work directory alien://%s/%s, should be done by the manager! ===\n", alien_workdir.Data(),gridhandler->GetGridOutputDir()); - TFile::Cp(Form("file:%s.jdl",kTrainName.Data()), Form("alien://%s/%s/%s.jdl",alien_workdir.Data(), - gridhandler->GetGridOutputDir(),kTrainName.Data())); + + TString dest; + dest = Form("%s/%s/%s.jdl",alien_workdir.Data(),gridhandler->GetGridOutputDir(),kTrainName.Data()); + if(AliAnalysisAlien::FileExists(dest.Data())){ + // Printf("%s exist on grid removing...",dest.Data()); + // gGrid->Rm(dest.Data()); + } + TFile::Cp(Form("file:%s.jdl",kTrainName.Data()),Form("alien://%s",dest.Data())); + + + TString dest; + dest = Form("%s/%s/%s_merge.jdl",alien_workdir.Data(),gridhandler->GetGridOutputDir(),kTrainName.Data()); + if(AliAnalysisAlien::FileExists(dest.Data())){ + // Printf("%s exist on grid removing...",dest.Data()); + // gGrid->Rm(dest.Data()); + } + TFile::Cp(Form("file:%s_merge.jdl",kTrainName.Data()),Form("alien://%s",dest.Data())); + + + dest = Form("%s/rootfiles/STEER/LQ1dRef_v1.root",gGrid->GetHomeDirectory()); + if(AliAnalysisAlien::FileExists(dest.Data())){ + Printf("%s exist on grid removing...",dest.Data()); + gGrid->Rm(dest.Data()); + } + TFile::Cp(Form("file:%s/STEER/LQ1dRef_v1.root", + gSystem->ExpandPathName("$ALICE_ROOT")),Form("alien://%s",dest.Data())); } AliLog::SetGlobalLogLevel(AliLog::kError); + if((kUseSysInfo>0&&smode=="LOCAL")||!strcmp(plugin_mode, "test")){ + TFile * fM = TFile::Open("manager_local.root","RECREATE"); + mgr->Write(); + fM->Close(); + } + + // grmpf, aliroot error handler overwrites root + gErrorIgnoreLevel = kErrorIgnoreLevel; + if(gErrorIgnoreLevel>3000) AliLog::SetGlobalLogLevel(AliLog::kFatal); StartAnalysis(smode, chain); + if((kUseSysInfo>0&&smode=="LOCAL")||!strcmp(plugin_mode, "test")){ + for(int i = 0;i < mgr->GetTopTasks()->GetEntries();i++){ + mgr->ProfileTask(i); + } + } if (!strcmp(plugin_mode, "offline")&&smode=="GRID"){ // Offline mode path files // PatchJDL(); @@ -568,7 +795,7 @@ void StartAnalysis(const char *mode, TChain *chain) { ::Error("AnalysisTrainPWG4Jets.C::StartAnalysis", "Cannot create the chain"); return; } - mgr->StartAnalysis(mode, chain); + mgr->StartAnalysis(mode, chain,kNumberOfEvents); return; case 1: if (!kProofDataSet.Length()) { @@ -583,13 +810,14 @@ void StartAnalysis(const char *mode, TChain *chain) { ::Error("AnalysisTrainPWG4Jets.C::StartAnalysis", "Grid plugin not initialized"); return; } - mgr->StartAnalysis("grid"); + mgr->StartAnalysis("grid",chain,kNumberOfEvents); } else { if (!chain) { ::Error("AnalysisTrainPWG4Jets.C::StartAnalysis", "Cannot create the chain"); return; } mgr->StartAnalysis(mode, chain); + mgr->StartAnalysis(mode, chain,kNumberOfEvents); } return; } @@ -649,10 +877,15 @@ void CheckModuleFlags(const char *mode) { iDIJETAN = 0; } // Disable tasks that do not work yet on AOD data + if(iPWG4JCORRAN)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG4 JCORRAN disabled in analysis on AOD's"); + iPWG4JCORRAN = 0; if( iPWG4PtQAMC)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG4 PtQAMC disabled in analysis on AOD's"); iPWG4PtQAMC = 0; if( iPWG4PtQATPC)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG4 PtTPC disabled in analysis on AOD's"); iPWG4PtQATPC = 0; + if( iPWG4Cosmics)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG4 Comics disabled in analysis on AOD's"); + iPWG4Cosmics = 0; + if( iPWG4PtSpectra)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG4 PtQAMC disabled in analysis on AOD's"); iPWG4PtSpectra = 0; if(iPWG4KMeans)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG4KMeans disabled on AOD's"); @@ -681,10 +914,12 @@ void CheckModuleFlags(const char *mode) { kUseKinefilter = kFALSE; if( iPWG4PtQAMC)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG4 PtQAMC disabled in analysis without MC"); iPWG4PtQAMC = 0; - + if( iPWG4CorrectionsUE)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG4 CorrectionsUE disabled in analysis without MC"); + iPWG4CorrectionsUE = 0; } if (!kUseTR) { - // ::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "iPWG2evchar disabled if not reading track references"); + if(iPWG4PtQAMC)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "iPWG4QATPCMC disabled if not reading track references"); + iPWG4PtQAMC = 0; } if (iJETAN){ iESDfilter=1; @@ -694,12 +929,17 @@ void CheckModuleFlags(const char *mode) { kUseMuonfilter = kFALSE; } if(!iJETAN){ - iPWG4JetSpectrum = iPWG4UE = iPWG4ThreeJets = iDIJETAN = 0; + iPWG4JetSpectrum = iPWG4UE = iPWG4CorrectionsUE = iPWG4ThreeJets = iDIJETAN = 0; } } - iPWG4JetTasks = iPWG4JetServices||iPWG4JetSpectrum||iPWG4UE||iPWG4PtQAMC||iPWG4PtSpectra||iPWG4PtQATPC||iPWG4ThreeJets; + iPWG4JetTasks = iPWG4JetServices||iPWG4JetSpectrum||iPWG4UE||iPWG4LeadingUE||iPWG4PtQAMC||iPWG4PtSpectra||iPWG4PtQATPC||iPWG4Cosmics||iPWG4ThreeJets||iPWG4JetChem||iPWG4Fragmentation; iPWG4PartCorrLibs = iPWG4PartCorr||iPWG4Tagged||iPWG4CaloQA; + iPWG4GammaConvLib = iPWG4GammaConv||iPWG4CaloConv; + + + iEMCUtilLibs = iPWG4PartCorrLibs||iPWG4JCORRAN||iPWG4GammaConvLib; iJETANLib = iPWG4JetTasks||iJETAN||iDIJETAN; + if (iESDfilter) {iAODhandler=1;} if (kUseKinefilter && !kUseMC) kUseKinefilter = kFALSE; if (kUseAODTags && !iAODhandler) kUseAODTags = kFALSE; @@ -791,7 +1031,7 @@ Bool_t LoadCommonLibraries(const char *mode) if (!strcmp(mode, "PROOF")) imode = 1; if (!strcmp(mode, "GRID")) imode = 2; if (!gSystem->Getenv("ALICE_ROOT")) { - ::Error("AnalysisTrainPWG4Jets.C::LoadCommonLibraries", "Analysis train requires that analysis libraries are compiled with a local AliRoot"); + ::Error("AnalysisTrainPWG4Jets.C::LoadCommonLibraries", "Analysis train requires that ALICE_ROOT is set to pick up Configurations"); return kFALSE; } Bool_t success = kTRUE; @@ -857,10 +1097,12 @@ Bool_t LoadCommonLibraries(const char *mode) Bool_t LoadAnalysisLibraries(const char *mode) { // Load common analysis libraries. - Bool_t success = kTRUE; + Bool_t success = kTRUE; if (iESDfilter) { + /* if (!LoadLibrary("PWG3base", mode, kTRUE) || !LoadLibrary("PWG3muon", mode, kTRUE)) return kFALSE; + */ } // JETAN if (iJETANLib) { @@ -890,29 +1132,44 @@ Bool_t LoadAnalysisLibraries(const char *mode) if (!LoadLibrary("FASTJETAN", mode, kTRUE)) return kFALSE; } if(iPWG4JetTasks){ - // PWG4 particle correlations if (!LoadLibrary("PWG4JetTasks", mode, kTRUE)) return kFALSE; } + if(iPWG1QASym){ - if (!LoadSource(Form("%s/prod/acrcaf/qa_pp/AliAnalysisTaskQASym.cxx",gSystem->ExpandPathName("$ALICE_ROOT")), mode, kTRUE))return kFALSE; + if (!LoadSource(Form("%s/PWG1/AliAnalysisTaskQASym.cxx",gSystem->ExpandPathName("$ALICE_ROOT")), mode, kTRUE))return kFALSE; } if(iPWG4TmpSourceSara){ - // gSystem->AddIncludePath("-I$ALICE_ROOT/include/JetTasks"); // ugly hack!! + if(!kUsePAR)gSystem->AddIncludePath("-I$ALICE_ROOT/include/JetTasks"); // ugly hack!! if(!LoadSource(Form("%s/PWG4/JetTasks/AliAnalysisTaskEta.cxx",gSystem->ExpandPathName("$ALICE_ROOT")), mode, kTRUE))return kFALSE; } + + /* + if(iPWG4JetChem){ + if(!kUsePAR)gSystem->AddIncludePath("-I$ALICE_ROOT/include/JetTasks"); // ugly hack!! + if(!LoadSource(Form("%s/PWG4/JetTasks/AliAnalysisTaskJetChem.cxx",gSystem->ExpandPathName("$ALICE_ROOT")), mode, kTRUE))return kFALSE; + } + */ + + if(iEMCUtilLibs){ + if (!LoadLibrary("EMCALUtils", mode, kTRUE) || + !LoadLibrary("PHOSUtils", mode, kTRUE)) return kFALSE; + } + if (iPWG4PartCorrLibs) { - if (!LoadLibrary("EMCALUtils", mode, kTRUE) || - !LoadLibrary("PHOSUtils", mode, kTRUE) || - !LoadLibrary("PWG4PartCorrBase", mode, kTRUE) || + if (!LoadLibrary("PWG4PartCorrBase", mode, kTRUE) || !LoadLibrary("PWG4PartCorrDep", mode, kTRUE)) return kFALSE; } + if(iPWG4JCORRAN){ + // PWG4 particle correlations + if(!LoadLibrary("PWG4JCORRAN",mode,kTRUE))return kFALSE; + } if (iPWG4JetCorr) { if (!LoadLibrary("PWG4JetCorrel", mode, kTRUE)) return kFALSE; } if (iPWG4omega3pi) { if (!LoadLibrary("PWG4omega3pi", mode, kTRUE)) return kFALSE; } - if (iPWG4GammaConv) { + if (iPWG4GammaConvLib) { if (!LoadLibrary("PWG4GammaConv", mode, kTRUE)) return kFALSE; } @@ -1003,7 +1260,7 @@ Bool_t LoadSource(const char *source, const char *mode, Bool_t rec=kFALSE) ::Error("AnalysisTrainPWG4Jets.C::LoadSource", "Empty task name"); return kFALSE; } - // we have a source code so compile it + // we have a source code so compile it if (ssource.EndsWith(".cxx")) { // need to copy it here other wise the path is also used on grid... ssource.Remove(ssource.Index(".cxx")); @@ -1140,8 +1397,8 @@ Int_t SetupPar(char* pararchivename) if (gSystem->AccessPathName(Form("%s.par", pararchivename))) { if (!gSystem->AccessPathName(Form("%s/%s.par", gSystem->Getenv("ALICE_ROOT"),pararchivename))) { ::Info("AnalysisTrainPWG4Jets.C::SetupPar", "Getting %s.par from $ALICE_ROOT", pararchivename); - TFile::Cp(gSystem->ExpandPathName(Form("$ALICE_ROOT/%s.par", pararchivename)), - Form("%s.par",pararchivename)); + TFile::Cp(gSystem->ExpandPathName(Form("$ALICE_ROOT/%s.par", pararchivename)), + Form("%s.par",pararchivename)); } else { ::Error("AnalysisTrainPWG4Jets.C::SetupPar", "Cannot find %s.par", pararchivename); return -1; @@ -1181,13 +1438,13 @@ AliAnalysisAlien* CreateAlienHandler(const char *plugin_mode) // Check if user has a valid token, otherwise make one. This has limitations. // One can always follow the standard procedure of calling alien-token-init then // source /tmp/gclient_env_$UID in the current shell. - if (!AliAnalysisGrid::CreateToken()) return NULL; +// if (!AliAnalysisGrid::CreateToken()) return NULL; AliAnalysisAlien *plugin = new AliAnalysisAlien(); // Set the run mode (can be "full", "test", "offline", "submit" or "terminate") plugin->SetRunMode(plugin_mode); if (kPluginUseProductionMode) plugin->SetProductionMode(); plugin->SetJobTag(kJobTag); - plugin->SetNtestFiles(2); + plugin->SetNtestFiles(1); // plugin->SetPreferedSE("ALICE::NIHAM::File"); // Set versions of used packages plugin->SetAPIVersion("V1.1x"); @@ -1201,7 +1458,8 @@ AliAnalysisAlien* CreateAlienHandler(const char *plugin_mode) plugin->SetGridDataDir(kGridDatadir.Data()); // Set data search pattern if (iAODanalysis) plugin->SetDataPattern(" *AliAOD.root"); - else plugin->SetDataPattern(Form(" %s/*/*ESD.tag.root",kGridPassPattern.Data())); + // else plugin->SetDataPattern(Form(" %s/*/*ESD.tag.root",kGridPassPattern.Data())); + else plugin->SetDataPattern(Form(" %s/*/*AliESDs.root",kGridPassPattern.Data())); // ...then add run numbers to be considered // plugin->SetRunRange(kGridRunRange[0], kGridRunRange[1]); for (Int_t i=kGridRunRange[0]; i<=kGridRunRange[1]; i++) { @@ -1213,6 +1471,8 @@ AliAnalysisAlien* CreateAlienHandler(const char *plugin_mode) ifstream in1; in1.open(kGridLocalRunList.Data()); int iRun; + + /* char c; char cLine[250]; while(!in1.eof()){ @@ -1228,7 +1488,23 @@ AliAnalysisAlien* CreateAlienHandler(const char *plugin_mode) { in1.putback (c); in1.getline(cLine,250); - Printf("AnalysisTrainPWG4Jets Skipping run number from File %s", cLine); + + } + } + */ + + Int_t nRun = 0; + + // just use run numbers, negatives will be excluded + while(in1>>iRun){ + + if(iRun>=0&&(nRunAddRunNumber(Form(kGridRunPattern.Data(),iRun)); + nRun++; + } + else{ + Printf("AnalysisTrainPWG4Jets Skipping run number from File %d", iRun); } } } @@ -1253,9 +1529,9 @@ AliAnalysisAlien* CreateAlienHandler(const char *plugin_mode) // Add external packages if (iJETAN||iDIJETAN) { - plugin->AddExternalPackage("boost::v1_38_0"); - plugin->AddExternalPackage("cgal::v3.3.1"); - plugin->AddExternalPackage("fastjet::v2.4.0"); + plugin->AddExternalPackage("boost::v1_43_0"); + plugin->AddExternalPackage("cgal::v3.6"); + plugin->AddExternalPackage("fastjet::v2.4.2"); } @@ -1288,15 +1564,19 @@ AliAnalysisAlien* CreateAlienHandler(const char *plugin_mode) if (ana_sources.Length()) plugin->SetAnalysisSource(ana_sources); plugin->SetExecutableCommand(kPluginExecutableCommand.Data()); -// Declare the output file names separated by blancs. -// (can be like: file.root or file.root@ALICE::Niham::File) - plugin->SetDefaultOutputs(); + // Declare the output file names separated by blancs. + // (can be like: file.root or file.root@ALICE::Niham::File) plugin->SetMergeExcludes(kGridMergeExclude); plugin->SetMaxMergeFiles(kGridMaxMergeFiles); plugin->SetNrunsPerMaster(kGridRunsPerMaster); -// Optionally define the files to be archived. -// plugin->SetOutputArchive("log_archive.zip:stdout,stderr@ALICE::NIHAM::File root_archive.zip:AliAOD.root,AOD.tag.root@ALICE::NIHAM::File"); - + plugin->SetMergeViaJDL(kPluginMergeViaJDL); + // Use fastread option + plugin->SetFastReadOption(kPluginFastReadOption); + // UseOverwrite mode + plugin->SetOverwriteMode(kPluginOverwriteMode); + // Optionally define the files to be archived. + // plugin->SetOutputArchive("log_archive.zip:stdout,stderr@ALICE::NIHAM::File root_archive.zip:AliAOD.root,AOD.tag.root@ALICE::NIHAM::File"); + plugin->SetOutputToRunNo(kPluginOutputToRunNumber); // write the output to subdirs named after run number // Put default output files to archive TString listhists = ""; @@ -1319,73 +1599,98 @@ AliAnalysisAlien* CreateAlienHandler(const char *plugin_mode) } } - if(kUseSysInfo>0){ - if (listhists.Length()) listhists += " "; - listhists += "syswatch.root"; - } - - if(kIsMC){ - if (listaods.Length()) listaods += " "; - listaods += "pyxsec_hists.root"; - } - - if (mgr->GetExtraFiles().Length()) { if (listaods.Length()) listaods += " "; listaods += mgr->GetExtraFiles(); } // if we do not fill the aod we do not need to store it - kGridMergeExclude = listaods; + // kGridMergeExclude = listaods; - if(!kFillAOD){ - listaods=""; + if(kSaveAOD!=0){ + TString outputFiles = ""; + outputFiles += mgr->GetExtraFiles(); + if (listhists.Length()) outputFiles += " "; + outputFiles += listhists; plugin->SetDefaultOutputs(kFALSE); - plugin->SetOutputFiles(listhists.Data()); + Printf("%s:%d Starting with the files %s",(char*)__FILE__,__LINE__,outputFiles.Data()); + // remove + // no harm done when we try to remove something that is not there :) + if(!(kSaveAOD&(1<<0))){ + outputFiles.ReplaceAll("AliAOD.root ",""); + listaods.ReplaceAll("AliAOD.root ",""); + } + if(!(kSaveAOD&(1<<1))){ + if(kDeltaAODJetName.Length())outputFiles.ReplaceAll(kDeltaAODJetName.Data(),""); + if(kDeltaAODJetName.Length())listaods.ReplaceAll(kDeltaAODJetName.Data(),""); + + } + if(!(kSaveAOD&(1<<2))){ + if(kDeltaAODPartCorrName.Length())outputFiles.ReplaceAll(kDeltaAODPartCorrName.Data(),""); + if(kDeltaAODPartCorrName.Length())listaods.ReplaceAll(kDeltaAODPartCorrName.Data(),""); + } + if(!(kSaveAOD&(1<<3))){ + if(kDeltaAODJCORRANName.Length())outputFiles.ReplaceAll(kDeltaAODJCORRANName.Data(),""); + if(kDeltaAODJCORRANName.Length())listaods.ReplaceAll(kDeltaAODJCORRANName.Data(),""); + } + + // + Printf("%s:%d Saving the files %s",(char*)__FILE__,__LINE__,outputFiles.Data()); + plugin->SetOutputFiles(outputFiles.Data()); } - + TString outputArchive; + outputArchive = Form("log_archive.zip:std*@%s","disk=1"); listaods.ReplaceAll(" ", ","); listhists.ReplaceAll(" ", ","); - if (listhists.Length()) listhists = Form("hist_archive.zip:%s@%s", listhists.Data(), kGridOutputStorages.Data());; - if (listaods.Length()) listaods = Form("aod_archive.zip:%s@%s", listaods.Data(), kGridOutputStorages.Data());; - - if (!listhists.Length() && !listaods.Length()) { + if (listhists.Length()){ + outputArchive += " "; + outputArchive += "root_archive.zip:"; + outputArchive += listhists; + if (listaods.Length()){ + outputArchive += ","; + outputArchive += listaods; + } + outputArchive += Form("@%s", kGridOutputStorages.Data()); + } + else{ + + if (listaods.Length()){ + // we have only aod'ish output + outputArchive += " "; + outputArchive += "root_archive.zip:"; + outputArchive += listaods; + outputArchive += Form("@%s", kGridOutputStorages.Data()); + } + else{ + // no other outputs than std.. ::Fatal("AnalysisTrainPWG4Jets", "No task output !"); + } } + plugin->SetDefaultOutputs(kFALSE); + plugin->SetOutputArchive(outputArchive); - TString outputArchive = "log_archive.zip:stdout,stderr@ALICE::FZK::SE,ALICE::GSI::SE"; - if(kUseSysInfo>0)outputArchive = "log_archive.zip:stdout,stderr,syswatch.log@ALICE::FZK::SE,ALICE::GSI::SE"; - if (listaods.Length()) { - outputArchive += " "; - outputArchive += listaods; - } - if (listhists.Length()) { - outputArchive += " "; - outputArchive += listhists; - } - plugin->SetOutputArchive(outputArchive); -// Optionally set a name for the generated analysis macro (default MyAnalysis.C) + // Optionally set a name for the generated analysis macro (default MyAnalysis.C) plugin->SetAnalysisMacro(Form("%s.C", kTrainName.Data())); -// Optionally set maximum number of input files/subjob (default 100, put 0 to ignore) + // Optionally set maximum number of input files/subjob (default 100, put 0 to ignore) plugin->SetSplitMaxInputFileNumber(kGridFilesPerJob); -// Optionally set number of failed jobs that will trigger killing waiting sub-jobs. -// plugin->SetMaxInitFailed(5); -// Optionally resubmit threshold. -// plugin->SetMasterResubmitThreshold(90); -// Optionally set time to live (default 30000 sec) - plugin->SetTTL(30000); -// Optionally set input format (default xml-single) + // Optionally set number of failed jobs that will trigger killing waiting sub-jobs. + plugin->SetMaxInitFailed(5); + // Optionally resubmit threshold. + // plugin->SetMasterResubmitThreshold(90); + // Optionally set time to live (default 30000 sec) + plugin->SetTTL(50400); // 14h... + // Optionally set input format (default xml-single) plugin->SetInputFormat("xml-single"); -// Optionally modify the name of the generated JDL (default analysis.jdl) + // Optionally modify the name of the generated JDL (default analysis.jdl) plugin->SetJDLName(Form("%s.jdl", kTrainName.Data())); -// Optionally modify the executable name (default analysis.sh) + // Optionally modify the executable name (default analysis.sh) plugin->SetExecutable(Form("%s.sh", kTrainName.Data())); -// Optionally modify job price (default 1) + // Optionally modify job price (default 1) plugin->SetPrice(1); -// Optionally modify split mode (default 'se') + // Optionally modify split mode (default 'se') plugin->SetSplitMode("se"); return plugin; } @@ -1478,13 +1783,13 @@ Bool_t PatchJDL(){ TGridJDL *jdl = gridHandler->GetGridJDL(); if(iJETAN)jdl->AddToPackages("fastjet","v2.4.0"); gridHandler->WriteJDL(kFALSE); - Printf("<<< Patching JDL"); + Printf("<<< Patching JDL"); return kTRUE; } Bool_t PatchAnalysisMacro(){ - Printf(">>> Patching AnalysisMacro"); - gSystem->Exec(Form("mv %s.C %s.C_tmp",kTrainName.Data(),kTrainName.Data())); + Printf(">>> Patching AnalysisMacro"); + gSystem->Exec(Form("mv %s.C %s.C_tmp",kTrainName.Data(),kTrainName.Data())); ifstream in1; in1.open(Form("%s.C_tmp", kTrainName.Data())); @@ -1494,28 +1799,52 @@ Bool_t PatchAnalysisMacro(){ st += cLine; st += "\n"; } - Int_t index; + Int_t index= -1; index = st.Index("gSystem->Load(\"libPhysics\");"); index += strlen("gSystem->Load(\"libPhysics\");"); - if(iJETAN&&kUsePAR){ + /* TObjArray *arr; TObjString *objstr; arr = anaLibs.Tokenize(" "); TIter next(arr); - TString add = ""; + add += "\n\n // added by CKB \n"; while ((objstr=(TObjString*)next())){ if(objstr->GetString().Contains("PWG3"))continue; if(objstr->GetString().EndsWith(".so"))add += Form("gSystem->Load(\"%s\");\n",objstr->GetString().Data()); } delete arr; + */ // add += Form("AliLog::SetGlobalLogLevel(%d);\n",AliLog::GetGlobalLogLevel()); - add += "// BKC \n\n"; - st.Insert(index,add.Data()); + TString add = ""; + + if(index<0)Printf("%s:%d index out of bounds",(char*)__FILE__,__LINE__); + add += "\n\n // added by CKB \n"; + if(kErrorIgnoreLevel>0)add += Form("gErrorIgnoreLevel = %d;\n",kErrorIgnoreLevel); + add += "\n gSystem->AddIncludePath(\"./\"); \n"; + if(gGrid&&kPluginAliRootVersion.Length()==0){ + add += "\n // Dirty hack for TRD reference data \n"; + add += "\n gSystem->Setenv(\"ALICE_ROOT\",\""; + add += Form("alien://%s/rootfiles/",gGrid->GetHomeDirectory()); + add += "\"); \n"; } + add += "// BKC \n\n"; + st.Insert(index,add.Data()); if(kUseDebug){ - st.Insert(index,"\n gROOT->ProcessLine(\".trace\"); // CKB \n"); + // st.Insert(index,"\n gROOT->ProcessLine(\".trace\"); // CKB \n"); + } + + if(kUseCPAR&&kPluginAliRootVersion.Length()==0){ + index = st.Index("gSystem->AddIncludePath(\"-I$"); // uncommen $ALICE_ROOT include for par files + if(index<0)Printf("%s:%d index out of bounds",(char*)__FILE__,__LINE__); + st.Insert(index,"// CKB comment out whehn no aliroot is provided \n //"); + } + + if(AliLog::GetGlobalLogLevel()==AliLog::kFatal){ + index = st.Index("AliLog::SetGlobal"); // ncomment setting of log level, do my own + if(index<0)Printf("%s:%d index out of bounds",(char*)__FILE__,__LINE__); + st.Insert(index,"AliLog::SetGlobalLogLevel(AliLog::kFatal);// CKB \n // CKB comment out for own setting \n //"); } ofstream out; @@ -1525,6 +1854,62 @@ Bool_t PatchAnalysisMacro(){ } out << st << endl; Printf("<<< Patching AnalysisMacro"); + + + + + + Printf(">>> Patching Merge Macro"); + gSystem->Exec(Form("mv %s_merge.C %s_merge.C_tmp",kTrainName.Data(),kTrainName.Data())); + + ifstream in2; + in2.open(Form("%s_merge.C_tmp", kTrainName.Data())); + TString st2; + while(in2.getline(cLine,250)){ + st2 += cLine; + st2 += "\n"; + } + index = st2.Index("gSystem->Load(\"libPhysics\");"); + index += strlen("gSystem->Load(\"libPhysics\");"); + TString add2 = ""; + add2 += "\n gSystem->AddIncludePath(\"./\"); \n"; + if(gGrid&&kPluginAliRootVersion.Length()==0){ + add2 += "\n // Dirty hack for TRD reference data \n"; + add2 += "\n gSystem->Setenv(\"ALICE_ROOT\",\""; + add2 += Form("alien://%s/rootfiles/",gGrid->GetHomeDirectory()); + add2 += "\"); \n"; + } + add2 += "// BKC \n\n"; + if(index<0)Printf("%s:%d index out of bounds",(char*)__FILE__,__LINE__); + st2.Insert(index,add.Data()); + + + if(kUseDebug){ + // st2.Insert(index,"\n gROOT->ProcessLine(\".trace\"); // CKB \n"); + } + + if(kUseCPAR&&kPluginAliRootVersion.Length()==0){ + index = st2.Index("gSystem->AddIncludePath(\"-I$"); // uncomment $ALICE_ROOT include for par files + if(index<0)Printf("%s:%d index out of bounds",(char*)__FILE__,__LINE__); + st2.Insert(index,"// CKB comment out whehn no aliroot is provided \n //"); + } + + // do not exclude the extra files from merign, this is done explicitly in this train script + index = st2.Index("mergeExcludes +="); // uncommen $ALICE_ROOT include for par files + if(index<0)Printf("%s:%d index out of bounds",(char*)__FILE__,__LINE__); + st2.Insert(index,"// CKB comment out, handled explicitly by the train macro \n //"); + + + ofstream out2; + out2.open(Form("%s_merge.C", kTrainName.Data())); + if (out2.bad()) { + return kFALSE; + } + out2 << st2 << endl; + Printf("<<< Patching Merging Macro"); + + + return kTRUE; }