]> git.uio.no Git - u/mrichter/AliRoot.git/blame - HMPID/AnalysisTrainHMPID.C
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ZDC automatic scripts updates (Marco Leoncino) + updates in QA config
[u/mrichter/AliRoot.git] / HMPID / AnalysisTrainHMPID.C
CommitLineData
66cdae53 1//===================== ANALYSIS TRAIN =========================================
2// To use: copy this macro to your work directory, modify the global part to match
3// your needs, then run root.
4// root[0] .L AnalysisTrainHMPID.C
5// Grid full mode as below (other modes: test, offline, submit, terminate)
6// root[1] AnalysisTrainHMPID("grid", "full")
7// CAF mode (requires root v5-23-02 + aliroot v4-16-Rev08)
8// root[2] AnalysisTrainHMPID("proof")
9// Local mode requires AliESds.root or AliAOD.root in ./data directory
10// root[3] AnalysisTrainHMPID("local")
11// In proof and grid modes, a token is needed and sourcing the produced environment file.
12//
13
14// =============================================================================
15// ### General Steering variables
16// =============================================================================
17//== general setup variables
18TString kTrainName = "hmpidAnalysis"; // (no blancs or special characters)
19TString kJobTag = "HMPID Tasks analysis train configured"; //
20Bool_t kUsePAR = kFALSE; // use par files for extra libs
21Bool_t kUseCPAR = kFALSE; // use par files for common libs
636bde73 22Bool_t kFillAOD = kFALSE; // switch of AOD filling for on the fly analysis
66cdae53 23
8e6dfee0 24Int_t iAODanalysis = 0; // Analysis on input AOD's
66cdae53 25Int_t iAODhandler = 1; // Analysis produces an AOD or dAOD's
26Int_t iESDfilter = 0; // ESD to AOD filter (barrel + muon tracks)
27Int_t iPhysicsSelection = 1; // Physics selection task
8e6dfee0 28Int_t iCentrality = 0; // Physics selection task
66cdae53 29Bool_t kUseKinefilter = kFALSE; // use Kinematics filter
30Bool_t kUseMuonfilter = kFALSE; // use muon filter
636bde73 31TString kCommonOutputFileName = "HmpidOutput.root";
66cdae53 32
33
34//== general process variables
35
36// ### Other flags to steer the analysis
37//==============================================================================
38Bool_t kSkipTerminate = kFALSE; // Do not call Teminate
39Bool_t kDebugLevel = kTRUE; // activate debugging
40Int_t kUseSysInfo = 0; // activate debugging
8e6dfee0 41Long64_t kNumberOfEvents = 1234567890; // number of events to process from the chain
42Bool_t kUseMC = kFALSE; // use MC info
43Bool_t kIsMC = kFALSE; // is MC info, if false it overwrites Use(AOD)MC
44Bool_t kUseESDTags = kFALSE; // use ESD tags for selection
66cdae53 45Bool_t kUseTR = kFALSE; // use track references
46
47// ### Analysis modules to be included. Some may not be yet fully implemented.
48//==============================================================================
a24020cd 49Int_t iHMPID = 1; // Basic HMPID analysis task
8e6dfee0 50Int_t iHMPIDperf = 0; // Basic HMPID performance task
f7071281 51Int_t iJETAN = 0; // Jet analysis (PWGJE) // 1 write standard 2 write non-standard jets
8e6dfee0 52Int_t iHMPIDJets = 0; // Jet chemistry with HMPID
66cdae53 53Int_t iJETANLib = 0;
54Int_t kHighPtFilterMask = 16; // change depending on the used AOD Filter
55
56
57//==============================================================================
58// ### PROOF Steering varibales
59//==============================================================================
60//== proof setup variables
61TString kProofCluster = "alice-caf.cern.ch";
62Bool_t kProofUseAFPAR = kTRUE; // use AF special par file
636bde73 63TString kProofAFversion = "VO_ALICE@AliRoot::v4-20-08-AN";
66cdae53 64//== proof input and output variables
636bde73 65TString kProofDataSet = "/alice/sim/LHC10d2_117220";
66cdae53 66//== proof process variables
67Bool_t kProofClearPackages = kFALSE;
68Int_t kProofEvents = 10000;
69Int_t kProofOffset = 0;
70
71//==============================================================================
72// ### Grid plugin Steering varibiables
73//==============================================================================
74//== grid plugin setup variables
75Bool_t kPluginUse = kTRUE; // do not change
76Bool_t kPluginUseProductionMode = kFALSE; // use the plugin in production mode
f7071281 77TString kPluginRootVersion = "v5-33-02b"; // *CHANGE ME IF MORE RECENT IN GRID*
78TString kPluginAliRootVersion = "v5-03-31-AN"; // *CHANGE ME IF MORE RECENT IN GRID*
636bde73 79Bool_t kPluginMergeViaJDL = kTRUE; // merge via JDL
66cdae53 80Bool_t kPluginFastReadOption = kFALSE; // use xrootd flags to reduce timeouts
81Bool_t kPluginOverwriteMode = kTRUE; // overwrite existing collections
82Int_t kPluginOutputToRunNumber = 1; // write the output to subdirs named after run number
8e6dfee0 83TString kPluginExecutableCommand = "aliroot -b -q";
66cdae53 84
85// == grid plugin input and output variables
8e6dfee0 86TString kGridDatadir = "/alice/data/2010/LHC10e";
66cdae53 87TString kGridLocalRunList = "";
8e6dfee0 88TString kGridWorkDir = ""; // Alien working directory
66cdae53 89TString kGridOutdir = ""; // AliEn output directory. If blank will become output_<kTrainName>
90TString kGridDataSet = ""; // sub working directory not to confuse different run xmls
8e6dfee0 91Int_t kGridRunRange[2] = {128260,128260}; // Set the run range
66cdae53 92TString kGridRunPattern = "%03d"; // important for leading zeroes!!
8e6dfee0 93TString kGridPassPattern = "/ESDs/pass2";
66cdae53 94TString kGridExtraFiles = ""; // files that will be added to the input list in the JDL...
95Int_t kGridMaxMergeFiles = 12; // Number of files merged in a chunk grid run range
8e6dfee0 96Int_t kGridMaxMergeStages = 3; // Number of stages in the merging procedure
66cdae53 97TString kGridMergeExclude = "AliAOD.root"; // Files that should not be merged
98TString kGridOutputStorages = "disk=2"; // Make replicas on the storages
99// == grid process variables
100Int_t kGridRunsPerMaster = 1; // Number of runs per master job
f7071281 101Int_t kGridFilesPerJob = 50; // Maximum number of files per job (gives size of AOD)
66cdae53 102
103//==============================================================================
104// ### Local Steering variables
105//==============================================================================
106//== local setup variables
107//== local input and output variables
108TString kLocalXMLDataset = ""; // Change local xml dataset for local interactive analysis
109TString kLocalDataList = "local_deltaaod.txt"; // Change local xml dataset for local interactive analysis
110// == local process variables
111
112
113
114// Temporaries.
115TString anaPars = "";
116TString anaLibs = "";
117TString anaLibsExtra = "";
118TString anaSources = "";
119// Function signatures
120class AliAnalysisAlien;
121
122//______________________________________________________________________________
123void AnalysisTrainHMPID(const char *analysis_mode="local", const char *plugin_mode="",
124 const char *config_file="",Int_t iOffset = 0)
125{
126// Main analysis train macro. If a configuration file is provided, all parameters
127// are taken from there but may be altered by CheckModuleFlags.
128
129 if (strlen(config_file) && !LoadConfig(config_file)) return;
130
131 if(iOffset)kProofOffset = iOffset;
132 TString smode(analysis_mode);
133 smode.ToUpper();
134 // Check compatibility of selected modules
135 CheckModuleFlags(smode);
136
137 printf("==================================================================\n");
138 printf("=========== RUNNING ANALYSIS TRAIN %s IN %s MODE ==========\n", kTrainName.Data(),smode.Data());
139 printf("==================================================================\n");
140 printf("= Configuring analysis train for: =\n");
8e6dfee0 141 if (iAODanalysis) printf("= AOD analysis =\n");
142 else printf("= ESD analysis =\n");
143 if (iPhysicsSelection) printf("= Physics selection =\n");
144 if (iCentrality) printf("= Centrality =\n");
66cdae53 145 if (iESDfilter) printf("= ESD filter =\n");
146 if (iJETAN) printf("= Jet analysis =\n");
8e6dfee0 147 if (iHMPID) printf("= HMPID generic =\n");
148 if (iHMPIDperf) printf("= HMPID performance =\n");
149 if (iHMPIDJets) printf("= HMPID Jet chemistry =\n");
66cdae53 150 printf("==================================================================\n");
151 printf(":: use MC truth %d\n", (UInt_t)kUseMC);
152 printf(":: use KINE filter %d\n", (UInt_t)kUseKinefilter);
153 printf(":: use track refs %d\n", (UInt_t)kUseTR);
154 printf(":: use tags %d\n", (UInt_t)kUseESDTags);
155 printf(":: use debugging %d\n", (UInt_t)kDebugLevel);
156 printf(":: use PAR files %d\n", (UInt_t)kUsePAR);
157 printf(":: use AliEn plugin %d\n", (UInt_t)kPluginUse);
158
159 //==========================================================================
160 // Connect to back-end system
161 if (!Connect(smode)) {
162 ::Error("AnalysisTrain", "Could not connect to %s back-end", analysis_mode);
163 return;
164 }
165
166 // Load common libraries and set include path
167 if (!LoadCommonLibraries(smode)) {
168 ::Error("AnalysisTrain", "Could not load common libraries");
169 return;
170 }
171
66cdae53 172
173 // Make the analysis manager and connect event handlers
174 AliAnalysisManager *mgr = new AliAnalysisManager("HMPIDTrain", "HMPID train");
175 if (kCommonOutputFileName.Length()>0)mgr->SetCommonFileName(kCommonOutputFileName.Data());
176 mgr->SetNSysInfo(0);
177 if (!strcmp(plugin_mode, "test")) mgr->SetNSysInfo(1);
178 if (kUseSysInfo)mgr->SetNSysInfo(kUseSysInfo);
179 mgr->SetSkipTerminate(kSkipTerminate);
180
181 // Load analysis specific libraries
182 if (!LoadAnalysisLibraries(smode)) {
183 ::Error("AnalysisTrain", "Could not load analysis libraries");
184 return;
185 }
186
187 // Create input handler (input container created automatically)
8e6dfee0 188 if (iAODanalysis) {
189 // AOD input handler
190 AliAODInputHandler *aodH = new AliAODInputHandler();
191 mgr->SetInputEventHandler(aodH);
192 } else {
66cdae53 193 // ESD input handler
8e6dfee0 194 AliESDInputHandler *esdHandler = new AliESDInputHandler();
195 if (kUseESDTags) esdHandler->SetReadTags();
f7071281 196 esdHandler->SetReadFriends(kFALSE);
8e6dfee0 197 mgr->SetInputEventHandler(esdHandler);
198 }
66cdae53 199
200 // Monte Carlo handler
8e6dfee0 201 if (kUseMC && !iAODanalysis) {
66cdae53 202 AliMCEventHandler* mcHandler = new AliMCEventHandler();
203 mgr->SetMCtruthEventHandler(mcHandler);
204 mcHandler->SetReadTR(kUseTR);
205 }
206
207 // AOD output container, created automatically when setting an AOD handler
208 if (iAODhandler) {
209 // AOD output handler
210 AliAODHandler* aodHandler = new AliAODHandler();
211 aodHandler->SetOutputFileName("AliAOD.root");
212 aodHandler->SetFillAODforRun(kFillAOD);
213
214 mgr->SetOutputEventHandler(aodHandler);
215 AliAnalysisDataContainer *cout_aod = mgr->GetCommonOutputContainer();
216 cout_aod->SetSpecialOutput();
217 }
218
219 // Debugging if needed
220 if (kDebugLevel){
221 mgr->SetDebugLevel(3);
222 }
223 if(kUseSysInfo>0){
224 mgr->RegisterExtraFile("syswatch.root");
225 if(kGridMergeExclude.Length())kGridMergeExclude += " ";
226 kGridMergeExclude += "syswatch.root";
227 } else {
228 AliLog::SetGlobalLogLevel(AliLog::kError);
229 }
230
231 //==========================================================================
232 // Create the chain. In this example it is created only from ALIEN files but
233 // can be done to work in batch or grid mode as well.
234 TChain *chain = CreateChain(smode, plugin_mode);
235
236 //==========================================================================
237 // Load the tasks configuration macros for all wagons. These files are supposed now to be
238 // in the current workdir, but in AliEn they will be in the file catalog,
239 // mapped from AliRoot and pecified in the jdl input list.
8e6dfee0 240 if(iPhysicsSelection && !iAODanalysis){
66cdae53 241 gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
242 AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(kIsMC,kTRUE,kTRUE); // last flag also adds information on
243 }
8e6dfee0 244
245 if(iCentrality && !iAODanalysis){
246 gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskCentrality.C");
247 AliCentralitySelectionTask *taskCentrality = AddTaskCentrality();
248 taskCentrality->SetPass(2); // remember to set the pass you are processing!!!
249 }
66cdae53 250
8e6dfee0 251 if (iESDfilter && !iAODanalysis) {
66cdae53 252 // ESD filter task configuration.
253 gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskESDFilter.C");
254 AliAnalysisTaskESDfilter *taskesdfilter = AddTaskESDFilter(kUseKinefilter,kUseMuonfilter);
f7071281 255// if jet analysis is included, better use the following macro with kHighPtFilterMask=272
256/* gROOT->LoadMacro("$ALICE_ROOT/PWGJE/macros/AddTaskESDFilterPWGJETrain.C");
257 AliAnalysisTaskESDfilter *taskesdfilter = AddTaskESDFilterPWGJETrain(kUseKinefilter,kUseMuonfilter);
258 taskesdfilter->DisableV0s();
259 taskesdfilter->DisableCascades();
260 taskesdfilter->DisableKinks();
261 taskesdfilter->DisablePmdClusters();
262 taskesdfilter->DisableCaloClusters();
263 taskesdfilter->DisableCells();*/
66cdae53 264 if(kIsMC){
265 mgr->RegisterExtraFile("pyxsec_hists.root");
266 if(kGridMergeExclude.Length())kGridMergeExclude += " ";
267 kGridMergeExclude += "pyxsec_hists.root";
268 }
269 }
270
271 // Jet analysis
272 if (iJETAN) {
f7071281 273 gROOT->LoadMacro("$ALICE_ROOT/PWGJE/macros/AddTaskJets.C");
66cdae53 274 AliAnalysisTaskJets *taskjets = 0;
f7071281 275 if (iJETAN&1) taskjets = AddTaskJets("AOD","FASTJET",0.4,kHighPtFilterMask);
66cdae53 276 if (!taskjets) ::Warning("AnalysisTrainHMPID", "AliAnalysisTaskJets cannot run for this train conditions - EXCLUDED");
277 }
278
279 if(iHMPID){
280 gROOT->LoadMacro("$ALICE_ROOT/HMPID/AddTaskHMPID.C");
281 AliHMPIDAnalysisTask *taskHmpid = AddTaskHMPID(kUseMC);
8e6dfee0 282 if (!taskHmpid) ::Warning("AnalysisTrainHMPID", "AliHMPIDAnalysisTask cannot run for this train conditions - EXCLUDED");
ce6ae14b 283 }
8e6dfee0 284
285 if(iHMPIDperf){
286 gROOT->LoadMacro("$ALICE_ROOT/HMPID/AddTaskHMPIDPerformance.C");
287 AliHMPIDPerformanceTask *taskHmpidPerformance = AddTaskHMPIDPerformance(kUseMC);
288 if (!taskHmpidPerformance) ::Warning("AnalysisTrainHMPID", "AliHMPIDPerformanceTask cannot run for this train conditions - EXCLUDED");
289 }
290
291 if(iHMPIDJets){
292 gROOT->LoadMacro("$ALICE_ROOT/HMPID/AddTaskJetsHMPID.C");
f7071281 293 AliAnalysisTaskJetsHMPID *taskHmpidJets = AddTaskJetsHMPID("jetsAOD_FASTJET04_B0_Filter00272_Cut00150","jeteventbackground_clustersAOD_KT04_B0_Filter00256_Cut00150_Skip00");
8e6dfee0 294 if (!taskHmpidJets) ::Warning("AnalysisTrainHMPID", "AliAnalysisTaskJetsHMPID cannot run for this train conditions - EXCLUDED");
295 }
296
66cdae53 297 if (kPluginUse) {
298 AliAnalysisGrid *alienHandler = CreateAlienHandler(plugin_mode);
299 AliAnalysisManager::GetAnalysisManager()->SetGridHandler(alienHandler);
300 }
301
302 if (mgr->InitAnalysis()) {
303 mgr->PrintStatus();
304 if (!strcmp(plugin_mode,"submit") && smode=="GRID"){
305 TString alien_workdir = gGrid->GetHomeDirectory();
306 alien_workdir += kGridWorkDir.Data();
307 if(kGridDataSet.Length()>0)alien_workdir += Form("/%s",kGridDataSet.Data());
308 AliAnalysisAlien *gridhandler = (AliAnalysisAlien*)mgr->GetGridHandler();
309 printf("=== AnalysisTrainHMPID:: Registering jdl in the work directory alien://%s/%s, should be done by the manager! ===\n",
310 alien_workdir.Data(),gridhandler->GetGridOutputDir());
311
312 TString dest;
313 dest = Form("%s/%s/%s.jdl",alien_workdir.Data(),gridhandler->GetGridOutputDir(),kTrainName.Data());
314 if(AliAnalysisAlien::FileExists(dest.Data())){
315 // Printf("%s exist on grid removing...",dest.Data());
316 // gGrid->Rm(dest.Data());
317 }
318 TFile::Cp(Form("file:%s.jdl",kTrainName.Data()),Form("alien://%s",dest.Data()));
319
320
321 TString dest;
322 dest = Form("%s/%s/%s_merge.jdl",alien_workdir.Data(),gridhandler->GetGridOutputDir(),kTrainName.Data());
323 if(AliAnalysisAlien::FileExists(dest.Data())){
324 // Printf("%s exist on grid removing...",dest.Data());
325 // gGrid->Rm(dest.Data());
326 }
327 TFile::Cp(Form("file:%s_merge.jdl",kTrainName.Data()),Form("alien://%s",dest.Data()));
328 }
329
330 AliLog::SetGlobalLogLevel(AliLog::kError);
331 if((kUseSysInfo>0 && smode=="LOCAL") || !strcmp(plugin_mode, "test")){
332 TFile *fM = TFile::Open("manager_local.root","RECREATE");
333 mgr->Write();
334 fM->Close();
335 }
336
337 StartAnalysis(smode, chain);
338
339 if((kUseSysInfo>0 && smode=="LOCAL") || !strcmp(plugin_mode, "test")){
340 for(int i = 0;i < mgr->GetTopTasks()->GetEntries();i++){
341 mgr->ProfileTask(i);
342 }
343 }
344 if (!strcmp(plugin_mode, "offline") && smode=="GRID"){
345 // Offline mode path files
346 // PatchJDL();
347 PatchAnalysisMacro();
348 }
349 }
350}
351
352
353//______________________________________________________________________________
354void StartAnalysis(const char *mode, TChain *chain) {
355
356 Int_t imode = -1;
357 AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
358 if (!strcmp(mode, "LOCAL")) imode = 0;
359 if (!strcmp(mode, "PROOF")) imode = 1;
360 if (!strcmp(mode, "GRID")) imode = 2;
361 switch (imode) {
362 case 0:
363 if (!chain) {
364 ::Error("AnalysisTrainHMPID.C::StartAnalysis", "Cannot create the chain");
365 return;
366 }
8e6dfee0 367 mgr->StartAnalysis(mode, chain, kNumberOfEvents);
66cdae53 368 return;
369 case 1:
370 if (!kProofDataSet.Length()) {
371 ::Error("AnalysisTrainHMPID.C::StartAnalysis", "kProofDataSet is empty");
372 return;
373 }
374 mgr->StartAnalysis(mode, kProofDataSet, kProofEvents,kProofOffset);
375 return;
376 case 2:
377 if (kPluginUse) {
378 if (!mgr->GetGridHandler()) {
379 ::Error("AnalysisTrainHMPID.C::StartAnalysis", "Grid plugin not initialized");
380 return;
381 }
382 mgr->StartAnalysis("grid");
383 } else {
384 if (!chain) {
385 ::Error("AnalysisTrainHMPID.C::StartAnalysis", "Cannot create the chain");
386 return;
387 }
388 mgr->StartAnalysis(mode, chain);
389 }
390 return;
391 }
392}
393
394//______________________________________________________________________________
395void CheckModuleFlags(const char *mode) {
396// Checks selected modules and insure compatibility
397 Int_t imode = -1;
398 if (!strcmp(mode, "LOCAL")) imode = 0;
399 if (!strcmp(mode, "PROOF")) imode = 1;
400 if (!strcmp(mode, "GRID")) imode = 2;
401
402
403 if (kUseCPAR) {
404 kPluginAliRootVersion = ""; // NO aliroot if we use CPAR
405 }
406
407 if (imode==1) {
408 if (!kUsePAR) {
409 ::Info("AnalysisTrainHMPID.C::CheckModuleFlags", "PAR files enabled due to PROOF analysis");
410 kUsePAR = kTRUE;
411 }
412 }
413 if (imode != 2) {
414 ::Info("AnalysisTrainHMPID.C::CheckModuleFlags", "AliEn plugin disabled since not in GRID mode");
415 kPluginUse = kFALSE;
416 }
417
418 if(!kIsMC){
8e6dfee0 419 // switch off anything related to MC
420 kUseMC = kFALSE;
421 kUseTR = kFALSE;
66cdae53 422 }
423
8e6dfee0 424 if (iAODanalysis) {
425 // AOD analysis
426 if (kUseMC)
f7071281 427 ::Info("AnalysisTrainHMPID.C::CheckModuleFlags", "MC usage disabled in analysis on AOD's");
8e6dfee0 428 kUseMC = kFALSE;
429 kUseTR = kFALSE;
430 if (iESDfilter)
f7071281 431 ::Info("AnalysisTrainHMPID.C::CheckModuleFlags", "ESD filter disabled in analysis on AOD's");
8e6dfee0 432 iESDfilter = 0;
433 if (iPhysicsSelection)
f7071281 434 ::Info("AnalysisTrainHMPID.C::CheckModuleFlags", "Physics Selection disabled in analysis on AOD's");
8e6dfee0 435 iPhysicsSelection = 0;
436 if (!iAODhandler) {
437 if (iJETAN)
f7071281 438 ::Info("AnalysisTrainHMPID.C::CheckModuleFlags", "JETAN disabled in analysis on AOD's without AOD handler");
8e6dfee0 439 iJETAN = 0;
440 }
f7071281 441 if(iHMPID)::Info("AnalysisTrainHMPID.C::CheckModuleFlags", "HMPID analysis disabled in analysis on AOD's");
8e6dfee0 442 iHMPID = 0;
f7071281 443 if(iHMPIDperf)::Info("AnalysisTrainHMPID.C::CheckModuleFlags", "HMPID performance disabled in analysis on AOD's");
8e6dfee0 444 iHMPIDperf = 0;
445 } else {
446 // ESD analysis
447 if (!kUseMC){
448 kUseTR = kFALSE;
449 if(kUseKinefilter)::Info("AnalysisTrainHMPID.C::CheckModuleFlags", "Kine Filter disabled in analysis without MC");
450 kUseKinefilter = kFALSE;
451 }
452 if (iJETAN){
453 iESDfilter=1;
454 }
455 if (!iESDfilter){
456 kUseKinefilter = kFALSE;
457 kUseMuonfilter = kFALSE;
458 }
66cdae53 459 }
460
461 iJETANLib = iJETAN && 1;
462 if (iESDfilter) {iAODhandler=1;}
463 if (kUseKinefilter && !kUseMC) kUseKinefilter = kFALSE;
464
465}
466
467
468//______________________________________________________________________________
469Bool_t Connect(const char *mode) {
470// Connect <username> to the back-end system.
471 Int_t imode = -1;
472 if (!strcmp(mode, "LOCAL")) imode = 0;
473 if (!strcmp(mode, "PROOF")) imode = 1;
474 if (!strcmp(mode, "GRID")) imode = 2;
475 TString username = gSystem->Getenv("alien_API_USER");
476 switch (imode) {
477 case 0:
478 break;
479 case 1:
480 if (!username.Length()) {
481 ::Error(Form("AnalysisTrainHMPID.C::Connect <%s>", mode), "Make sure you:\n \
482 1. Have called: alien-token-init <username>\n \
483 2. Have called: >source /tmp/gclient_env_$UID");
484 return kFALSE;
485 }
486 ::Info("AnalysisTrainHMPID.C::Connect", "Connecting user <%s> to PROOF cluster <%s>",
487 username.Data(), kProofCluster.Data());
488 gEnv->SetValue("XSec.GSI.DelegProxy", "2");
489 TProof::Open(Form("%s@%s", username.Data(), kProofCluster.Data()));
490 if (!gProof) {
491 if (strcmp(gSystem->Getenv("XrdSecGSISRVNAMES"), "lxfsrd0506.cern.ch"))
492 ::Error(Form("AnalysisTrainHMPID.C::Connect <%s>", mode), "Environment XrdSecGSISRVNAMES different from lxfsrd0506.cern.ch");
493 return kFALSE;
494 }
495 if(kProofClearPackages)gProof->ClearPackages();
496 break;
497 case 2:
498 if (!username.Length()) {
499 ::Error(Form("AnalysisTrainHMPID.C::Connect <%s>", mode), "Make sure you:\n \
500 1. Have called: alien-token-init <username>\n \
501 2. Have called: >source /tmp/gclient_env_$UID");
502 return kFALSE;
503 }
504 if (kPluginUse && !gSystem->Getenv("alien_CLOSE_SE")) {
505 ::Error(Form("AnalysisTrainHMPID.C::Connect <%s>", mode),
506 "When using the AliEn plugin it is preferable to define the \
507 variable alien_CLOSE_SE in your environment.");
508 return kFALSE;
509 }
510 ::Info("AnalysisTrainHMPID.C::Connect", "Connecting user <%s> to AliEn ...",
511 username.Data());
512 TGrid::Connect("alien://");
513 if (!gGrid || !gGrid->IsConnected()) return kFALSE;
514 break;
515 default:
516 ::Error("AnalysisTrainHMPID.C::Connect", "Unknown run mode: %s", mode);
517 return kFALSE;
518 }
519 ::Info("AnalysisTrainHMPID.C::Connect","Connected in %s mode", mode);
520 return kTRUE;
521}
522
523
524//______________________________________________________________________________
525Bool_t LoadCommonLibraries(const char *mode)
526{
527// Load common analysis libraries.
528 Int_t imode = -1;
529 if (!strcmp(mode, "LOCAL")) imode = 0;
530 if (!strcmp(mode, "PROOF")) imode = 1;
531 if (!strcmp(mode, "GRID")) imode = 2;
532 if (!gSystem->Getenv("ALICE_ROOT")) {
533 ::Error("AnalysisTrainHMPID.C::LoadCommonLibraries", "Analysis train requires that analysis libraries are compiled with a local AliRoot");
534 return kFALSE;
535 }
536 Bool_t success = kTRUE;
537 // ROOT libraries
538 gSystem->Load("libTree.so");
539 gSystem->Load("libGeom.so");
540 gSystem->Load("libVMC.so");
541 gSystem->Load("libPhysics.so");
542
543 // Load framework classes. Par option ignored here.
544 switch (imode) {
545 case 0:
546 case 2:
547 if (kUseCPAR) {
548 success &= LoadLibrary("STEERBase", mode, kTRUE);
549 success &= LoadLibrary("ESD", mode, kTRUE);
550 success &= LoadLibrary("AOD", mode, kTRUE);
551 success &= LoadLibrary("ANALYSIS", mode, kTRUE);
552 success &= LoadLibrary("ANALYSISalice", mode, kTRUE);
553 success &= LoadLibrary("CORRFW", mode, kTRUE);
554 } else {
9130f705 555 success &= LoadLibrary("libSTEERBase.so", mode, kTRUE);
556 success &= LoadLibrary("libESD.so", mode, kTRUE);
557 success &= LoadLibrary("libAOD.so", mode, kTRUE);
558 success &= LoadLibrary("libANALYSIS.so", mode, kTRUE);
559 success &= LoadLibrary("libANALYSISalice.so", mode, kTRUE);
560 success &= LoadLibrary("libCORRFW.so", mode, kTRUE);
66cdae53 561 gROOT->ProcessLine(".include $ALICE_ROOT/include");
f7071281 562 }
66cdae53 563 break;
564 case 1:
565 if (!kProofUseAFPAR) {
566 success &= LoadLibrary("STEERBase", mode);
567 success &= LoadLibrary("ESD", mode);
568 success &= LoadLibrary("AOD", mode);
569 success &= LoadLibrary("ANALYSIS", mode);
570 success &= LoadLibrary("ANALYSISalice", mode);
571 success &= LoadLibrary("CORRFW", mode);
f7071281 572 } else {
66cdae53 573 success &= !gProof->EnablePackage(kProofAFversion);
574 success &= LoadLibrary("CORRFW", mode);
575 }
f7071281 576 break;
66cdae53 577 default:
578 ::Error("AnalysisTrainHMPID.C::LoadCommonLibraries", "Unknown run mode: %s", mode);
579 return kFALSE;
580 }
581 if (success) {
582 ::Info("AnalysisTrainHMPID.C::LoadCommodLibraries", "Load common libraries: SUCCESS");
583 ::Info("AnalysisTrainHMPID.C::LoadCommodLibraries", "Include path for Aclic compilation:\n%s",
584 gSystem->GetIncludePath());
f7071281 585 } else {
66cdae53 586 ::Info("AnalysisTrainHMPID.C::LoadCommodLibraries", "Load common libraries: FAILED");
f7071281 587 }
588
66cdae53 589 return success;
590}
591
592
593//______________________________________________________________________________
594Bool_t LoadAnalysisLibraries(const char *mode)
595{
596// Load common analysis libraries.
597 Bool_t success = kTRUE;
598 if (iESDfilter) {
f7071281 599 if (!LoadLibrary("PWGHFbase", mode, kTRUE) ||
600 !LoadLibrary("PWGmuon", mode, kTRUE)) return kFALSE;
66cdae53 601 }
602
f7071281 603 if (iJETANLib) {
604 // this part needs some rework in case we do not need the fastjed finders for processing
605 if (!LoadLibrary("JETAN", mode, kTRUE)) return kFALSE;
606 if (!strcmp(mode, "PROOF")){
607 gProof->Exec("gSystem->Load\(\"/afs/cern.ch/user/d/dperrino/public/libCGAL.so\"\)", kTRUE);
608 gProof->Exec("gSystem->Load\(\"/afs/cern.ch/user/d/dperrino/public/libfastjet.so\"\)", kTRUE);
609 // problem when loading siscone copiled with different gcc version??
610 // gProof->Exec("gSystem->Load\(\"/afs/cern.ch/user/d/dperrino/public/libsiscone.so\"\)", kTRUE);
611 gProof->Exec("gSystem->Load\(\"/afs/cern.ch/user/d/dperrino/public/libSISConePlugin.so\"\)", kTRUE);
612 }
613 if(!kUsePAR){
614 if (!LoadLibrary("CGAL", mode, kTRUE)) return kFALSE;
615 if (!LoadLibrary("fastjet", mode, kTRUE)) return kFALSE;
616 if (!LoadLibrary("siscone", mode, kTRUE)) return kFALSE;
617 if (!LoadLibrary("SISConePlugin", mode, kTRUE)) return kFALSE;
618 }
619 else{
620 if (!LoadLibrary("libCGAL.so", mode, kTRUE)) return kFALSE;
621 if (!LoadLibrary("libfastjet.so", mode, kTRUE)) return kFALSE;
622 if (!LoadLibrary("libsiscone.so", mode, kTRUE)) return kFALSE;
623 if (!LoadLibrary("libSISConePlugin.so", mode, kTRUE)) return kFALSE;
624 }
625 if (!LoadLibrary("FASTJETAN", mode, kTRUE)) return kFALSE;
626 }
627
66cdae53 628 if(iHMPID){
629 if (!LoadSource(Form("%s/HMPID/AliHMPIDAnalysisTask.cxx",gSystem->ExpandPathName("$ALICE_ROOT")), mode, kTRUE))return kFALSE;
630 }
8e6dfee0 631
632 if(iHMPIDperf){
633 if (!LoadSource(Form("%s/HMPID/AliHMPIDPerformanceTask.cxx",gSystem->ExpandPathName("$ALICE_ROOT")), mode, kTRUE))return kFALSE;
634 }
66cdae53 635
8e6dfee0 636 if(iHMPIDJets){
637 if (!LoadSource(Form("%s/HMPID/AliAnalysisTaskJetsHMPID.cxx",gSystem->ExpandPathName("$ALICE_ROOT")), mode, kTRUE))return kFALSE;
638 }
639
66cdae53 640 if (iJETANLib) {
641 if (!LoadLibrary("JETAN", mode, kTRUE)) return kFALSE;
642 }
643
644 ::Info("AnalysisTrainHMPID.C::LoadAnalysisLibraries", "Load other libraries: SUCCESS");
645 return kTRUE;
646}
647
648
649//______________________________________________________________________________
650Bool_t LoadLibrary(const char *module, const char *mode, Bool_t rec=kFALSE)
651{
652// Load a module library in a given mode. Reports success.
653 Int_t imode = -1;
654 Int_t result;
655 TString smodule(module);
656 if (!strcmp(mode, "LOCAL")) imode = 0;
657 if (!strcmp(mode, "PROOF")) imode = 1;
658 if (!strcmp(mode, "GRID")) imode = 2;
659 TString mod(module);
660 if (!mod.Length()) {
661 ::Error("AnalysisTrainHMPID.C::LoadLibrary", "Empty module name");
662 return kFALSE;
663 }
664 // If a library is specified, just load it
665 if (smodule.EndsWith(".so")) {
666 mod.Remove(mod.Index(".so"));
667 result = gSystem->Load(mod);
668 if (result < 0) {
669 ::Error("AnalysisTrainHMPID.C::LoadLibrary", "Could not load library %s", module);
670 return kFALSE;
671 }
672 if (rec) anaLibs += Form("%s.so ",mod.Data());
673 if (rec) anaLibsExtra += Form("%s.so ",mod.Data());
674 return kTRUE;
675 }
676 // Check if the library is already loaded
677 if (strlen(gSystem->GetLibraries(Form("%s.so", module), "", kFALSE)) > 0)
678 return kTRUE;
679 switch (imode) {
680 case 0:
681 case 2:
682 if (kUsePAR) {
683 result = SetupPar(module);
684 if (rec) anaPars += Form("%s.par ", module);
685 } else {
686 result = gSystem->Load(Form("lib%s.so", module));
687 if (rec) anaLibs += Form("lib%s.so ", module);
688 }
689 break;
690 case 1:
691 if(!gSystem->AccessPathName(module)){
692 ::Info("AnalysisTrainHMPID.C::LoadLibrary", "Removing directory %s",module);
693 gSystem->Exec(Form("rm -rf %s",module));
694 }
695 result = gProof->UploadPackage(module);
696 if (result<0) {
697 result = gProof->UploadPackage(gSystem->ExpandPathName(Form("$ALICE_ROOT/%s.par", module)));
698 if (result<0) {
699 ::Error("AnalysisTrainHMPID.C::LoadLibrary", "Could not find module %s.par in current directory nor in $ALICE_ROOT", module);
700 return kFALSE;
701 }
702 }
703 result = gProof->EnablePackage(module);
704 break;
705 default:
706 return kFALSE;
707 }
708 if (result < 0) {
709 ::Error("AnalysisTrainHMPID.C::LoadLibrary", "Could not load module %s", module);
710 return kFALSE;
711 }
712 return kTRUE;
713}
714
715//______________________________________________________________________________
716Bool_t LoadSource(const char *source, const char *mode, Bool_t rec=kFALSE)
717{
718// Load a module library in a given mode. Reports success.
719 Int_t imode = -1;
720 Int_t result = -1;
721 if (!strcmp(mode, "LOCAL")) imode = 0;
722 if (!strcmp(mode, "PROOF")) imode = 1;
723 if (!strcmp(mode, "GRID")) imode = 2;
724 TString ssource(source);
725 TString basename = gSystem->BaseName(ssource.Data());
726 if (!ssource.Length()) {
727 ::Error("AnalysisTrainHMPID.C::LoadSource", "Empty task name");
728 return kFALSE;
729 }
730 // we have a source code so compile it
731 if (ssource.EndsWith(".cxx")) {
732 // need to copy it here other wise the path is also used on grid...
733 ssource.Remove(ssource.Index(".cxx"));
734 basename.Remove(basename.Index(".cxx"));
735 Printf("LoadSources:: Copying... path %s{cxx,h}",ssource.Data());
736 gSystem->Exec(Form("cp %s.cxx . ",ssource.Data()));
737 gSystem->Exec(Form("cp %s.h . ",ssource.Data()));
738 // Path to code
739 // only needed for local compilation, in grid and proof mode
740 // the task headers are uploaded
741 // path.Remove(path.Index(gSystem->BaseName(path.Data())));
742 // Printf("LoadSources:: Including path %s",path.Data());
743 // if(path.Length()>0)gROOT->ProcessLine(Form(".include %s",path.Data()));
744 Printf("LoadSources:: Loading... path %s",basename.Data());
745 switch (imode) {
746 case 0:
747 result = gROOT->LoadMacro(Form("%s.cxx++g",basename.Data()));
748 break;
749 case 1:
750 result = gProof->Load(Form("%s.cxx++g",basename.Data()));
751 break;
752 case 2:
753 result = gROOT->LoadMacro(Form("%s.cxx++g",basename.Data()));
754 if (rec){
755 // what we want to compile
756 anaSources += Form("%s.cxx ",basename.Data());
757 // what we need as input...
758 anaLibs += Form("%s.cxx %s.h ",basename.Data(),basename.Data());
759 }
760 break;
761 default:
762 return kFALSE;
763 }
764 }
765 if (result < 0) {
766 ::Error("AnalysisTrainHMPID.C::LoadSources", "Could not load source %s", source);
767 return kFALSE;
768 }
769 return kTRUE;
770}
771
772//______________________________________________________________________________
773TChain *CreateChain(const char *mode, const char *plugin_mode)
774{
775// Create the input chain
776 Int_t imode = -1;
777 if (!strcmp(mode, "LOCAL")) imode = 0;
778 if (!strcmp(mode, "PROOF")) imode = 1;
779 if (!strcmp(mode, "GRID")) imode = 2;
780 TChain *chain = NULL;
781 // Local chain
782 switch (imode) {
783 case 0:
8e6dfee0 784 if (iAODanalysis) {
785 if (!kLocalXMLDataset.Length()) {
786 // Local AOD
787 chain = new TChain("aodTree");
788 TString line;
789 ifstream in;
790 in.open(kLocalDataList.Data());
791 while (in.good()) {
792 in >> line;
793 if (line.Length() == 0) continue;
794 // cout << " line = " << line << endl;
795 chain->Add(line.Data());
796 }
797 } else {
798 // Interactive AOD
799 chain = CreateChainSingle(kLocalXMLDataset, "aodTree");
800 }
801 } else {
802 if (!kLocalXMLDataset.Length()) {
803 // Local ESD
804 chain = new TChain("esdTree");
805 TString line;
806 ifstream in;
807 in.open(kLocalDataList.Data());
808 while (in.good()) {
809 in >> line;
810 if (line.Length() == 0) continue;
811 cout << " line = " << line << endl;
812 chain->Add(line.Data());
813 }
814 } else {
815 // Interactive ESD
816 chain = CreateChainSingle(kLocalXMLDataset, "esdTree");
817 }
818 }
66cdae53 819 break;
820 case 1:
821 break;
822 case 2:
823 if (kPluginUse) {
824 AliAnalysisGrid *alienHandler = CreateAlienHandler(plugin_mode);
825 AliAnalysisManager::GetAnalysisManager()->SetGridHandler(alienHandler);
826 } else {
8e6dfee0 827 TString treeName = "esdTree";
828 if (iAODanalysis) treeName = "aodTree";
66cdae53 829 chain = CreateChainSingle("wn.xml", treeName);
830 }
831 break;
832 default:
833 }
834 if (chain && chain->GetNtrees()) return chain;
835 return NULL;
836}
837
838//______________________________________________________________________________
839TChain* CreateChainSingle(const char* xmlfile, const char *treeName)
840{
841 printf("*******************************\n");
842 printf("*** Getting the ESD Chain ***\n");
843 printf("*******************************\n");
844 TAlienCollection * myCollection = TAlienCollection::Open(xmlfile);
845
846 if (!myCollection) {
847 ::Error("AnalysisTrainHMPID.C::CreateChainSingle", "Cannot create an AliEn collection from %s", xmlfile) ;
848 return NULL ;
849 }
850
851 TChain* chain = new TChain(treeName);
852 myCollection->Reset() ;
853 while ( myCollection->Next() ) chain->Add(myCollection->GetTURL("")) ;
854 chain->ls();
855 return chain;
856}
857
858//______________________________________________________________________________
859Int_t SetupPar(char* pararchivename)
860{
861 if (!pararchivename || !strlen(pararchivename)) return -1;
862 char processline[1024];
863 if (gSystem->AccessPathName(Form("%s.par", pararchivename))) {
864 if (!gSystem->AccessPathName(Form("%s/%s.par", gSystem->Getenv("ALICE_ROOT"),pararchivename))) {
865 ::Info("AnalysisTrainHMPID.C::SetupPar", "Getting %s.par from $ALICE_ROOT", pararchivename);
866 TFile::Cp(gSystem->ExpandPathName(Form("$ALICE_ROOT/%s.par", pararchivename)),
867 Form("%s.par",pararchivename));
868 } else {
869 ::Error("AnalysisTrainHMPID.C::SetupPar", "Cannot find %s.par", pararchivename);
870 return -1;
871 }
872 }
873 gSystem->Exec(Form("tar xvzf %s.par", pararchivename));
874
875 TString ocwd = gSystem->WorkingDirectory();
876 if (!gSystem->ChangeDirectory(pararchivename)) return -1;
877
878 // check for BUILD.sh and execute
879 if (!gSystem->AccessPathName("PROOF-INF/BUILD.sh")) {
880 printf("*******************************\n");
881 printf("*** Building PAR archive ***\n");
882 printf("*******************************\n");
883 if (gSystem->Exec("PROOF-INF/BUILD.sh")) {
884 Error("runProcess","Cannot Build the PAR Archive! - Abort!");
885 return -1;
886 }
887 }
888
889 // check for SETUP.C and execute
890 if (!gSystem->AccessPathName("PROOF-INF/SETUP.C")) {
891 printf("*******************************\n");
892 printf("*** Setup PAR archive ***\n");
893 printf("*******************************\n");
894 gROOT->Macro("PROOF-INF/SETUP.C");
895 }
896 if (!gSystem->ChangeDirectory(ocwd.Data())) return -1;
897 return 0;
898}
899
900//______________________________________________________________________________
901AliAnalysisAlien* CreateAlienHandler(const char *plugin_mode)
902{
903// Check if user has a valid token, otherwise make one. This has limitations.
904// One can always follow the standard procedure of calling alien-token-init then
905// source /tmp/gclient_env_$UID in the current shell.
906 if (!AliAnalysisGrid::CreateToken()) return NULL;
907 AliAnalysisAlien *plugin = new AliAnalysisAlien();
908// Set the run mode (can be "full", "test", "offline", "submit" or "terminate")
909 plugin->SetRunMode(plugin_mode);
910 if (kPluginUseProductionMode) plugin->SetProductionMode();
911 plugin->SetJobTag(kJobTag);
636bde73 912 plugin->SetNtestFiles(1);
66cdae53 913// plugin->SetPreferedSE("ALICE::NIHAM::File");
914// Set versions of used packages
915 plugin->SetAPIVersion("V1.1x");
916 plugin->SetROOTVersion(kPluginRootVersion);
917 plugin->SetAliROOTVersion(kPluginAliRootVersion);
918
919// Declare input data to be processed.
920// Method 1: Create automatically XML collections using alien 'find' command.
921// Define production directory LFN
922 plugin->SetGridDataDir(kGridDatadir.Data());
923// Set data search pattern
8e6dfee0 924 if (iAODanalysis) plugin->SetDataPattern(" *AliAOD.root");
925 else plugin->SetDataPattern(Form(" %s/*/*ESDs.root",kGridPassPattern.Data()));
66cdae53 926// ...then add run numbers to be considered
8e6dfee0 927 plugin->SetRunPrefix("000"); // if real data
66cdae53 928 plugin->SetRunRange(kGridRunRange[0], kGridRunRange[1]);
929
930 if(kGridLocalRunList.Length()>0){
931 ifstream in1;
932 in1.open(kGridLocalRunList.Data());
933 int iRun;
934 // just use run numbers, negatives will be excluded
935 while(in1>>iRun){
936 if(iRun>0){
937 Printf("AnalysisTrainHMPID Adding run number from File %s", Form(kGridRunPattern.Data(),iRun));
938 plugin->AddRunNumber(Form(kGridRunPattern.Data(),iRun));
939 } else{
940 Printf("AnalysisTrainHMPID Skipping run number from File %d", iRun);
941 }
942 }
943 }
944
945// Method 2: Declare existing data files (raw collections, xml collections, root file)
946// If no path mentioned data is supposed to be in the work directory (see SetGridWorkingDir())
947// XML collections added via this method can be combined with the first method if
948// the content is compatible (using or not tags)
949// plugin->AddDataFile("Hijing.xml");
950// plugin->AddDataFile("/alice/data/2008/LHC08c/000057657/raw/Run57657.Merged.RAW.tag.root");
951// Define alien work directory where all files will be copied. Relative to alien $HOME.
952 TString alien_workdir = "";
953
954 alien_workdir += kGridWorkDir.Data();
955 if(kGridDataSet.Length()>0)alien_workdir += Form("/%s",kGridDataSet.Data());
956 plugin->SetGridWorkingDir(alien_workdir.Data());
957
958 // Declare alien output directory. Relative to working directory.
959 if (!kGridOutdir.Length()) kGridOutdir = Form("output_%s",kTrainName.Data());
960 plugin->SetGridOutputDir(kGridOutdir);
961
f7071281 962 // Add external packages
963 if (iJETAN) {
964 plugin->AddExternalPackage("boost::v1_43_0");
965 plugin->AddExternalPackage("cgal::v3.6");
966 plugin->AddExternalPackage("fastjet::v2.4.2");
967 }
968
66cdae53 969 // set extra libs before par file compilation
970 anaLibs += kGridExtraFiles;
971 anaLibs = anaLibs.Strip();
972 Printf("anaLibs %s",anaLibs.Data());
973 Printf("anaLibsExtra %s",anaLibsExtra.Data());
974
975 if (anaLibs.Length()) plugin->SetAdditionalLibs(anaLibs.Data());
976 if (anaLibsExtra.Length()) plugin->SetAdditionalRootLibs(anaLibsExtra.Data());
977
978 TString ana_sources = "";
979 TString ana_add = "";
980 if (kUsePAR && anaPars.Length()) {
981 printf("%s\n", anaPars.Data());
982 TObjArray *arr;
983 TObjString *objstr;
984 arr = anaPars.Tokenize(" ");
985 TIter next(arr);
986 while ((objstr=(TObjString*)next())) plugin->EnablePackage(objstr->GetString());
987 delete arr;
988 }
989
990// Declare the analysis source files names separated by blancs. To be compiled runtime
991// using ACLiC on the worker nodes.
992 ana_sources = anaSources.Strip();
993// Declare all libraries (other than the default ones for the framework. These will be
994// loaded by the generated analysis macro. Add all extra files (task .cxx/.h) here.
995
996 if (ana_sources.Length()) plugin->SetAnalysisSource(ana_sources);
636bde73 997 plugin->SetExecutableCommand(kPluginExecutableCommand.Data());
66cdae53 998 // Declare the output file names separated by blancs.
999 // (can be like: file.root or file.root@ALICE::Niham::File)
636bde73 1000 plugin->SetUseSubmitPolicy(kFALSE);
66cdae53 1001 plugin->SetMergeExcludes(kGridMergeExclude);
1002 plugin->SetMaxMergeFiles(kGridMaxMergeFiles);
8e6dfee0 1003 plugin->SetMaxMergeStages(kGridMaxMergeStages);
66cdae53 1004 plugin->SetNrunsPerMaster(kGridRunsPerMaster);
1005 plugin->SetMergeViaJDL(kPluginMergeViaJDL);
1006 // Use fastread option
1007 plugin->SetFastReadOption(kPluginFastReadOption);
1008 // UseOverwrite mode
636bde73 1009 plugin->SetOverwriteMode(kPluginOverwriteMode);
66cdae53 1010 // Optionally define the files to be archived.
1011 // plugin->SetOutputArchive("log_archive.zip:stdout,stderr@ALICE::NIHAM::File root_archive.zip:AliAOD.root,AOD.tag.root@ALICE::NIHAM::File");
1012 plugin->SetOutputToRunNo(kPluginOutputToRunNumber); // write the output to subdirs named after run number
1013// plugin->SetDefaultOutputs(kFALSE);
1014
1015 // Put default output files to archive
1016 TString listhists = "";
1017 TString listaods = "";
1018 AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
1019 TIter next(mgr->GetOutputs());
1020 AliAnalysisDataContainer *output;
1021 while ((output=(AliAnalysisDataContainer*)next())) {
1022 const char *filename = output->GetFileName();
1023 if (!(strcmp(filename, "default"))) {
1024 if (!mgr->GetOutputEventHandler()) continue;
1025 filename = mgr->GetOutputEventHandler()->GetOutputFileName();
1026 if (listaods.Length()) listaods += " ";
1027 listaods += filename;
1028 } else {
1029 if(!listhists.Contains(filename)){
1030 if (listhists.Length()) listhists += " ";
1031 listhists += filename;
1032 }
1033 }
1034 }
1035
1036 if (mgr->GetExtraFiles().Length()) {
1037 if (listaods.Length()) listaods += " ";
1038 listaods += mgr->GetExtraFiles();
1039 }
1040
1041 TString outputArchive;
1042 outputArchive = Form("log_archive.zip:std*r@%s",kGridOutputStorages.Data());
1043 listaods.ReplaceAll(" ", ",");
1044 listhists.ReplaceAll(" ", ",");
1045 if (listhists.Length()) listhists = Form("hist_archive.zip:%s@%s", listhists.Data(), kGridOutputStorages.Data());
1046 if (listaods.Length()) listaods = Form("aod_archive.zip:%s@%s", listaods.Data(), kGridOutputStorages.Data());
1047
1048 if (!listhists.Length() && !listaods.Length()) {
1049 ::Fatal("AnalysisTrainHMPID", "No task output !");
1050 }
636bde73 1051
66cdae53 1052 if (listaods.Length()) {
1053 outputArchive += " ";
1054 outputArchive += listaods;
636bde73 1055 }
66cdae53 1056 if (listhists.Length()) {
1057 outputArchive += " ";
1058 outputArchive += listhists;
636bde73 1059 }
66cdae53 1060// plugin->SetOutputArchive(outputArchive);
1061
1062// Optionally set a name for the generated analysis macro (default MyAnalysis.C)
1063 plugin->SetAnalysisMacro(Form("%s.C", kTrainName.Data()));
1064// Optionally set maximum number of input files/subjob (default 100, put 0 to ignore)
1065 plugin->SetSplitMaxInputFileNumber(kGridFilesPerJob);
1066// Optionally set number of failed jobs that will trigger killing waiting sub-jobs.
1067// plugin->SetMaxInitFailed(5);
1068// Optionally resubmit threshold.
1069// plugin->SetMasterResubmitThreshold(90);
1070// Optionally set time to live (default 30000 sec)
1071 plugin->SetTTL(30000);
1072// Optionally set input format (default xml-single)
1073 plugin->SetInputFormat("xml-single");
1074// Optionally modify the name of the generated JDL (default analysis.jdl)
1075 plugin->SetJDLName(Form("%s.jdl", kTrainName.Data()));
1076// Optionally modify the executable name (default analysis.sh)
1077 plugin->SetExecutable(Form("%s.sh", kTrainName.Data()));
1078// Optionally modify job price (default 1)
1079 plugin->SetPrice(1);
1080// Optionally modify split mode (default 'se')
1081 plugin->SetSplitMode("se");
1082 plugin->SetCheckCopy(kFALSE);
1083 return plugin;
1084}
1085
1086//______________________________________________________________________________
1087Bool_t LoadConfig(const char *filename)
1088{
1089// Read train configuration from file
1090 if (gSystem->AccessPathName(filename)) {
1091 ::Error("AnalysisTrainHMPID.C::LoadConfig", "Config file name not found");
1092 return kFALSE;
1093 }
1094 gROOT->ProcessLine(Form(".x %s", filename));
1095 ::Info("AnalysisTrainHMPID.C::LoadConfig", "Train configuration loaded from file %s", filename);
1096 return kTRUE;
1097}
1098
1099//______________________________________________________________________________
1100Bool_t PatchJDL(){
1101 Printf(">>> Patching JDL");
1102 AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
1103 AliAnalysisAlien* gridHandler = (AliAnalysisAlien*)mgr->GetGridHandler();
1104 TGridJDL *jdl = gridHandler->GetGridJDL();
1105 if(iJETAN)jdl->AddToPackages("fastjet","v2.4.0");
1106 gridHandler->WriteJDL(kFALSE);
1107 Printf("<<< Patching JDL");
1108 return kTRUE;
1109}
1110
1111//______________________________________________________________________________
1112Bool_t PatchAnalysisMacro(){
1113 Printf(">>> Patching AnalysisMacro");
1114 gSystem->Exec(Form("mv %s.C %s.C_tmp",kTrainName.Data(),kTrainName.Data()));
1115
1116 ifstream in1;
1117 in1.open(Form("%s.C_tmp", kTrainName.Data()));
1118 char cLine[250];
1119 TString st;
1120 while(in1.getline(cLine,250)){
1121 st += cLine;
1122 st += "\n";
1123 }
1124 Int_t index= -1;
1125 index = st.Index("gSystem->Load(\"libPhysics\");");
1126 index += strlen("gSystem->Load(\"libPhysics\");");
1127 /*
1128 TObjArray *arr;
1129 TObjString *objstr;
1130 arr = anaLibs.Tokenize(" ");
1131 TIter next(arr);
1132
1133 add += "\n\n // added by CKB \n";
1134 while ((objstr=(TObjString*)next())){
1135 if(objstr->GetString().Contains("PWG3"))continue;
1136 if(objstr->GetString().EndsWith(".so"))add += Form("gSystem->Load(\"%s\");\n",objstr->GetString().Data());
1137 }
1138 delete arr;
1139 */
1140 // add += Form("AliLog::SetGlobalLogLevel(%d);\n",AliLog::GetGlobalLogLevel());
1141 TString add = "";
1142
1143 if(index<0)Printf("%s:%d index out of bounds",(char*)__FILE__,__LINE__);
1144 add += "\n\n // added by CKB \n";
1145 add += "\n gSystem->AddIncludePath(\"./\"); \n";
1146 if(gGrid && kPluginAliRootVersion.Length()==0){
1147 add += "\n // Dirty hack for TRD reference data \n";
1148 add += "\n gSystem->Setenv(\"ALICE_ROOT\",\"";
1149 add += Form("alien://%s/rootfiles/",gGrid->GetHomeDirectory());
1150 add += "\"); \n";
1151 }
1152 add += "// BKC \n\n";
1153 st.Insert(index,add.Data());
1154
1155 if(kUseCPAR && kPluginAliRootVersion.Length()==0){
1156 index = st.Index("gSystem->AddIncludePath(\"-I$"); // uncommen $ALICE_ROOT include for par files
1157 if(index<0)Printf("%s:%d index out of bounds",(char*)__FILE__,__LINE__);
1158 st.Insert(index,"// CKB comment out whehn no aliroot is provided \n //");
1159 }
1160
1161 ofstream out;
1162 out.open(Form("%s.C", kTrainName.Data()));
1163 if (out.bad()) {
1164 return kFALSE;
1165 }
1166 out << st << endl;
1167 Printf("<<< Patching AnalysisMacro");
1168
1169 Printf(">>> Patching Merge Macro");
1170 gSystem->Exec(Form("mv %s_merge.C %s_merge.C_tmp",kTrainName.Data(),kTrainName.Data()));
1171
1172 ifstream in2;
1173 in2.open(Form("%s_merge.C_tmp", kTrainName.Data()));
1174 TString st2;
1175 while(in2.getline(cLine,250)){
1176 st2 += cLine;
1177 st2 += "\n";
1178 }
1179 index = st2.Index("gSystem->Load(\"libPhysics\");");
1180 index += strlen("gSystem->Load(\"libPhysics\");");
1181 TString add2 = "";
1182 add2 += "\n gSystem->AddIncludePath(\"./\"); \n";
1183 if(gGrid&&kPluginAliRootVersion.Length()==0){
1184 add2 += "\n // Dirty hack for TRD reference data \n";
1185 add2 += "\n gSystem->Setenv(\"ALICE_ROOT\",\"";
1186 add2 += Form("alien://%s/rootfiles/",gGrid->GetHomeDirectory());
1187 add2 += "\"); \n";
1188 }
1189 add2 += "// BKC \n\n";
1190 if(index<0)Printf("%s:%d index out of bounds",(char*)__FILE__,__LINE__);
1191 st2.Insert(index,add.Data());
1192
1193 if(kUseCPAR&&kPluginAliRootVersion.Length()==0){
1194 index = st2.Index("gSystem->AddIncludePath(\"-I$"); // uncommen $ALICE_ROOT include for par files
1195 if(index<0)Printf("%s:%d index out of bounds",(char*)__FILE__,__LINE__);
1196 st2.Insert(index,"// CKB comment out whehn no aliroot is provided \n //");
1197 }
1198
1199 // do not exclude the extra files from merign, this is done explicitly in this train script
1200 index = st2.Index("mergeExcludes +="); // uncommen $ALICE_ROOT include for par files
1201 if(index<0)Printf("%s:%d index out of bounds",(char*)__FILE__,__LINE__);
1202 st2.Insert(index,"// CKB comment out, handled explicitly by the train macro \n //");
1203
1204
1205 ofstream out2;
1206 out2.open(Form("%s_merge.C", kTrainName.Data()));
1207 if (out2.bad()) {
1208 return kFALSE;
1209 }
1210 out2 << st2 << endl;
1211 Printf("<<< Patching Merging Macro");
1212
1213
1214 return kTRUE;
1215
1216}