]> git.uio.no Git - u/mrichter/AliRoot.git/blame - ANALYSIS/macros/AnalysisTrainNew.C
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Header file corresponding to 32066
[u/mrichter/AliRoot.git] / ANALYSIS / macros / AnalysisTrainNew.C
CommitLineData
c6e7c68c 1//===================== ANALYSIS TRAIN ==========================================
2// To use: copy this macro to your work directory, modify the global part to match
3// your needs, then run root.
4// root[0] .L AnalysisTrain.C
5// Grid full mode as below (other modes: test, offline, submit, terminate)
6// root[1] AnalysisTrainNew("grid", "full")
7// CAF mode (requires root v5-23-02 + aliroot v4-16-Rev08)
8// root[2] AnalysisTrainNew("proof")
9// Local mode requires AliESds.root or AliAOD.root in the work directory
10// root[3] AnalysisTrainNew("local")
11
12const char *root_version = "v5-23-02";
13const char *aliroot_version = "v4-16-Rev-08";
14const char *cluster = "alicecaf.cern.ch";
15//const char *AFversion = "AF-v4-16";
16const char *AFversion = "";
17// Dataset name. If empty assumes local ESD/AOD. In CAF it is a dataset name.
18// In grid has to point to an xml file or be empty if using the plugin
19// === PROOF
20const char *proof_dataset = "/COMMON/COMMON/LHC09a4_run8100X#/esdTree";
21
22// === ALIEN
23const char *dataset = "";
24const char *alien_datadir = "/alice/sim/PDC_09/LHC09a4/";
099d8f33 25Int_t run_numbers[10] = {81072, 0, 0, 0, 0,
c6e7c68c 26 0, 0, 0, 0, 0};
27
28Bool_t useDBG = kTRUE;
099d8f33 29Bool_t useMC = kTRUE;
30Bool_t useTAGS = kFALSE;
31Bool_t useKFILTER = kTRUE;
32Bool_t usePAR = kFALSE;
c6e7c68c 33Bool_t useTR = kFALSE;
34Bool_t usePLUGIN = kTRUE;
35Bool_t useCORRFW = kFALSE; // do not change
099d8f33 36Bool_t useAODTAGS = kTRUE;
c6e7c68c 37
38Int_t iAODanalysis = 0;
39Int_t iAODhandler = 1;
40Int_t iESDfilter = 1;
c6e7c68c 41Int_t iMUONcopyAOD = 0;
42Int_t iJETAN = 1;
43Int_t iPWG4partcorr = 1;
44Int_t iPWG4pi0 = 1;
45Int_t iPWG3vertexing = 0;
46Int_t iPWG2femto = 0;
47Int_t iPWG2spectra = 1;
48Int_t iPWG2flow = 0;
49Int_t iPWG2res = 0;
50
51TString anaPars = "";
52TString anaLibs = "";
53// Function signatures
54class AliAnalysisGrid;
55
56//______________________________________________________________________________
57void AnalysisTrainNew(const char *analysis_mode="grid", const char *plugin_mode="test")
58{
59// Example of running analysis train
60 TString smode(analysis_mode);
61 smode.ToUpper();
62 // Check compatibility of selected modules
63 CheckModuleFlags(smode);
64
65 printf("==================================================================\n");
66 printf("=========== RUNNING ANALYSIS TRAIN IN %s MODE ==========\n", smode.Data());
67 printf("==================================================================\n");
68 printf("= Configuring analysis train for: =\n");
69 if (iAODanalysis) printf("= AOD analysis =\n");
70 else printf("= ESD analysis =\n");
71 if (iESDfilter) printf("= ESD filter =\n");
c6e7c68c 72 if (iMUONcopyAOD) printf("= MUON copy AOD =\n");
73 if (iJETAN) printf("= Jet analysis =\n");
f0e8e44e 74 if (iPWG2spectra) printf("= PWG2 proton, checkCascade, checkV0, strange =\n");
c6e7c68c 75 if (iPWG2femto) printf("= PWG2 femtoscopy =\n");
76 if (iPWG2flow) printf("= PWG2 flow =\n");
77 if (iPWG2res) printf("= PWG2 resonances =\n");
78 if (iPWG3vertexing) printf("= PWG3 vertexing =\n");
79 if (iPWG4partcorr) printf("= PWG4 gamma-hadron correlations =\n");
80 if (iPWG4pi0) printf("= PWG4 pi0 analysis =\n");
81 printf("==================================================================\n");
82 printf(":: use MC truth %d\n", (UInt_t)useMC);
099d8f33 83 printf(":: use KINE filter %d\n", (UInt_t)useKFILTER);
c6e7c68c 84 printf(":: use track refs %d\n", (UInt_t)useTR);
099d8f33 85 printf(":: use tags %d\n", (UInt_t)useTAGS);
86 printf(":: use AOD tags %d\n", (UInt_t)useAODTAGS);
c6e7c68c 87 printf(":: use debugging %d\n", (UInt_t)useDBG);
88 printf(":: use PAR files %d\n", (UInt_t)usePAR);
89 printf(":: use AliEn plugin %d\n", (UInt_t)usePLUGIN);
90
91 // Connect to back-end system
92 if (!Connect(smode)) {
93 ::Error("AnalysisTrain", "Could not connect to %s back-end", analysis_mode);
94 return;
95 }
96
97 // Load common libraries and set include path
98 if (!LoadCommonLibraries(smode)) {
99 ::Error("AnalysisTrain", "Could not load common libraries");
100 return;
101 }
102
103 // Load analysis specific libraries
104 if (!LoadAnalysisLibraries(smode)) {
105 ::Error("AnalysisTrain", "Could not load analysis libraries");
106 return;
107 }
108
109
110 //==========================================================================
111 // Make the analysis manager and connect event handlers
112 AliAnalysisManager *mgr = new AliAnalysisManager("Analysis Train", "Production train");
113
114 // Create input handler (input container created automatically)
115 if (iAODanalysis) {
116 // AOD input handler
117 AliAODInputHandler *aodH = new AliAODInputHandler();
118 mgr->SetInputEventHandler(aodH);
119 } else {
120 // ESD input handler
121 AliESDInputHandler *esdHandler = new AliESDInputHandler();
099d8f33 122 if (useTAGS) esdHandler->SetReadTags();
c6e7c68c 123 mgr->SetInputEventHandler(esdHandler);
124 }
125 // Monte Carlo handler
126 if (useMC && !iAODanalysis) {
127 AliMCEventHandler* mcHandler = new AliMCEventHandler();
128 mgr->SetMCtruthEventHandler(mcHandler);
129 mcHandler->SetReadTR(useTR);
130 }
131 // AOD output container, created automatically when setting an AOD handler
132 if (iAODhandler) {
133 // AOD output handler
134 AliAODHandler* aodHandler = new AliAODHandler();
135 mgr->SetOutputEventHandler(aodHandler);
136 aodHandler->SetOutputFileName("AliAOD.root");
137 }
138 // Debugging if needed
139 if (useDBG) mgr->SetDebugLevel(3);
140
141 //==========================================================================
142 // Create the chain. In this example it is created only from ALIEN files but
143 // can be done to work in batch or grid mode as well.
144 TChain *chain = CreateChain(smode, plugin_mode);
145
146 //==========================================================================
147 // Load the tasks configuration macros for all wagons. These files are supposed now to be
148 // in the current workdir, but in AliEn they will be in the file catalog,
149 // mapped from AliRoot and pecified in the jdl input list.
150
151 // For now connection to top input container and common AOD output container
152 // is done in this macro, but in future these containers will be connected
153 // from each task configuration macro.
154
155 if (iESDfilter && !iAODanalysis) {
156 // ESD filter task configuration.
157 gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskESDFilter.C");
099d8f33 158 AliAnalysisTaskESDfilter *taskesdfilter = AddTaskESDFilter(useKFILTER);
c6e7c68c 159 }
160
099d8f33 161 // AOD tags
162 if (useAODTAGS) {
163 AliAnalysisTaskTagCreator* tagTask = new AliAnalysisTaskTagCreator("AOD Tag Creator");
164 mgr->AddTask(tagTask);
165 AliAnalysisDataContainer *coutTags = mgr->CreateContainer("cTag", TTree::Class(),
166 AliAnalysisManager::kOutputContainer, "AOD.tag.root");
167 mgr->ConnectInput (tagTask, 0, mgr->GetCommonInputContainer());
168 mgr->ConnectOutput(tagTask, 1, coutTags);
c6e7c68c 169 }
170
171 // Jet analysis
172 if (iJETAN) {
173 gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskJets.C");
174 AliAnalysisTaskJets *taskjets = AddTaskJets("ESD", "UA1");
175 }
176
177 // Proton analysis
178 if (iPWG2spectra) {
f0e8e44e 179 // protons
c85963a0 180 gROOT->LoadMacro("$ALICE_ROOT/PWG2/SPECTRA/macros/AddTaskProtons.C");
c6e7c68c 181 AliAnalysisTaskProtons *taskprotons = AddTaskProtons();
f0e8e44e 182 // cascades
183 gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskCheckCascade.C");
184 AliAnalysisTaskCheckCascade *taskcheckcascade = AddTaskCheckCascade();
6e7f8264 185 // v0's
186 gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskCheckV0.C");
187 AliAnalysisTaskCheckV0 *taskcheckV0 = AddTaskCheckV0();
188 // strangeness
189 gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskStrange.C");
190 AliAnalysisTaskStrange *taskstrange = AddTaskStrange();
c6e7c68c 191 }
192
193 // PWG4 hadron correlations
194 if (iPWG4partcorr) {
099d8f33 195 gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskPartCorr.C");
196 AliAnalysisTaskParticleCorrelation *taskgammahadron = AddTaskPartCorr("GammaHadron", "AOD", "PHOS");
c6e7c68c 197 }
198
199 // PWG4 pi0
200 if (iPWG4pi0) {
099d8f33 201 gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskPartCorr.C");
202 AliAnalysisTaskParticleCorrelation *taskpi0 = AddTaskPartCorr("Pi0", "AOD", "PHOS");
c6e7c68c 203 }
204
205 //==========================================================================
206 // FOR THE REST OF THE TASKS THE MACRO AddTaskXXX() is not yet implemented/
207 // Run the analysis
208 //
209 if (mgr->InitAnalysis()) {
210 mgr->PrintStatus();
211 StartAnalysis(smode, chain);
212 }
213}
214
215//______________________________________________________________________________
216void StartAnalysis(const char *mode, TChain *chain) {
217// Start analysis.
218 Int_t imode = -1;
219 AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
220 if (!strcmp(mode, "LOCAL")) imode = 0;
221 if (!strcmp(mode, "PROOF")) imode = 1;
222 if (!strcmp(mode, "GRID")) imode = 2;
223 switch (imode) {
224 case 0:
225 if (!chain) {
226 ::Error("StartAnalysis", "Cannot create the chain");
227 return;
228 }
229 mgr->StartAnalysis(mode, chain);
230 return;
231 case 1:
232 if (!strlen(proof_dataset)) {
233 ::Error("StartAnalysis", "proof_dataset is empty");
234 return;
235 }
236 mgr->StartAnalysis(mode, proof_dataset, 1000);
237 return;
238 case 2:
239 if (usePLUGIN) {
240 if (!mgr->GetGridHandler()) {
241 ::Error("StartAnalysis", "Grid plugin not initialized");
242 return;
243 }
244 mgr->StartAnalysis("grid");
245 } else {
246 if (!chain) {
247 ::Error("StartAnalysis", "Cannot create the chain");
248 return;
249 }
250 mgr->StartAnalysis(mode, chain);
251 }
252 return;
253 }
254}
255
256//______________________________________________________________________________
257void CheckModuleFlags(const char *mode) {
258// Checks selected modules and insure compatibility
259 Int_t imode = -1;
260 if (!strcmp(mode, "LOCAL")) imode = 0;
261 if (!strcmp(mode, "PROOF")) imode = 1;
262 if (!strcmp(mode, "GRID")) imode = 2;
263 if (imode==1) {
264 usePAR = kTRUE;
265 }
266 if (iAODanalysis) {
267 // AOD analysis
268 useMC = kFALSE;
269 useTR = kFALSE;
270 iESDfilter = 0;
c6e7c68c 271 // Disable tasks that do not work yet on AOD data
272 } else {
273 // ESD analysis
274 iMUONcopyAOD = 0;
275 iPWG3vertexing = 0;
276 }
099d8f33 277 if (iJETAN) iESDfilter=1;
c6e7c68c 278 if (iESDfilter) iAODhandler=1;
279 if (iAODanalysis || !iAODhandler) {
280 iPWG4partcorr=0;
281 iPWG4pi0=0;
282 }
283 if (iPWG2spectra || iPWG2flow) useCORRFW = kTRUE;
099d8f33 284 if (useKFILTER && !useMC) useKFILTER = kFALSE;
285 if (useAODTAGS && !iAODhandler) useAODTAGS = kFALSE;
c6e7c68c 286}
287
288//______________________________________________________________________________
289Bool_t Connect(const char *mode) {
290// Connect <username> to the back-end system.
291 Int_t imode = -1;
292 if (!strcmp(mode, "LOCAL")) imode = 0;
293 if (!strcmp(mode, "PROOF")) imode = 1;
294 if (!strcmp(mode, "GRID")) imode = 2;
295 TString username = gSystem->Getenv("alien_API_USER");
296 switch (imode) {
297 case 0:
298 break;
299 case 1:
300 if (!username.Length()) {
301 ::Error(Form("Connect <%s>", mode), "Make sure you:\n \
302 1. Have called: alien-token-init <username>\n \
303 2. Have called: >source /tmp/gclient_env_$UID");
304 return kFALSE;
305 }
306 ::Info("Connect", "Connecting user <%s> to PROOF cluster <%s>",
307 username.Data(), cluster);
308 TProof::Open(Form("%s@%s", username.Data(), cluster));
309 if (!gProof) {
310 if (strcmp(gSystem->Getenv("XrdSecGSISRVNAMES"), "lxfsrd0506.cern.ch"))
311 ::Error(Form("Connect <%s>", mode), "Environment XrdSecGSISRVNAMES different from lxfsrd0506.cern.ch");
312 return kFALSE;
313 }
314 break;
315 case 2:
316 if (!username.Length()) {
317 ::Error(Form("Connect <%s>", mode), "Make sure you:\n \
318 1. Have called: alien-token-init <username>\n \
319 2. Have called: >source /tmp/gclient_env_$UID");
320 return kFALSE;
321 }
322 if (usePLUGIN && !gSystem->Getenv("alien_CLOSE_SE")) {
323 ::Error(Form("Connect <%s>", mode),
324 "When using the AliEn plugin it is preferable to define the \
325 variable alien_CLOSE_SE in your environment.");
326 return kFALSE;
327 }
328 ::Info("Connect", "Connecting user <%s> to AliEn ...",
329 username.Data());
330 TGrid::Connect("alien://");
331 if (!gGrid || !gGrid->IsConnected()) return kFALSE;
332 break;
333 default:
334 ::Error("Connect", "Unknown run mode: %s", mode);
335 return kFALSE;
336 }
337 ::Info("Connect","Connected in %s mode", mode);
338 return kTRUE;
339}
340
341//______________________________________________________________________________
342Bool_t LoadCommonLibraries(const char *mode)
343{
344// Load common analysis libraries.
345 Int_t imode = -1;
346 if (!strcmp(mode, "LOCAL")) imode = 0;
347 if (!strcmp(mode, "PROOF")) imode = 1;
348 if (!strcmp(mode, "GRID")) imode = 2;
349 if (!gSystem->Getenv("ALICE_ROOT")) {
350 ::Error("LoadCommonLibraries", "Analysis train requires that analysis libraries are compiled with a local AliRoot");
351 return kFALSE;
352 }
353 Bool_t success = kTRUE;
354 // ROOT libraries
355 gSystem->Load("libTree.so");
356 gSystem->Load("libGeom.so");
357 gSystem->Load("libVMC.so");
358 gSystem->Load("libPhysics.so");
359
360 // Load framework classes. Par option ignored here.
361 switch (imode) {
362 case 0:
363 case 2:
364 success &= LoadLibrary("libSTEERBase.so", mode);
365 success &= LoadLibrary("libESD.so", mode);
366 success &= LoadLibrary("libAOD.so", mode);
367 success &= LoadLibrary("libANALYSIS.so", mode);
368 success &= LoadLibrary("libANALYSISalice.so", mode);
369 if (useCORRFW) success &= LoadLibrary("libCORRFW.so", mode);
370 gROOT->ProcessLine(".include $ALICE_ROOT/include");
371 break;
372 case 1:
373 Int_t ires = -1;
374 if (!gSystem->AccessPathName(AFversion)) ires = gProof->UploadPackage(AFversion);
375 if (ires < 0) {
376 success &= LoadLibrary("STEERBase", mode);
377 success &= LoadLibrary("ESD", mode);
378 success &= LoadLibrary("AOD", mode);
379 success &= LoadLibrary("ANALYSIS", mode);
380 success &= LoadLibrary("ANALYSISalice", mode);
381 if (useCORRFW) success &= LoadLibrary("CORRFW", mode);
382 } else {
383 ires = gProof->EnablePackage(AFversion);
384 if (useCORRFW) success &= LoadLibrary("CORRFW", mode);
385 }
386 if (ires<0) success = kFALSE;
387 break;
388 default:
389 ::Error("LoadCommonLibraries", "Unknown run mode: %s", mode);
390 return kFALSE;
391 }
392 if (success) {
393 ::Info("LoadCommodLibraries", "Load common libraries: SUCCESS");
394 ::Info("LoadCommodLibraries", "Include path for Aclic compilation:\n%s",
395 gSystem->GetIncludePath());
396 } else {
397 ::Info("LoadCommodLibraries", "Load common libraries: FAILED");
398 }
399
400 return success;
401}
402
403//______________________________________________________________________________
404Bool_t LoadAnalysisLibraries(const char *mode)
405{
406// Load common analysis libraries.
407 Bool_t success = kTRUE;
099d8f33 408 if (iESDfilter) {
c6e7c68c 409 if (!LoadLibrary("PWG3base", mode, kTRUE) ||
410 !LoadLibrary("PWG3muon", mode, kTRUE)) return kFALSE;
411 }
412 // JETAN
413 if (iJETAN) {
414 if (!LoadLibrary("JETAN", mode, kTRUE)) return kFALSE;
415 }
416
417 // PWG4 particle correlations
418 if (iPWG4partcorr || iPWG4pi0) {
419 if (!LoadLibrary("PWG4PartCorrBase", mode, kTRUE) ||
420 !LoadLibrary("PWG4PartCorrDep", mode, kTRUE)) return kFALSE;
421 TFile::Cp(gSystem->ExpandPathName("$(ALICE_ROOT)/PWG4/macros/ConfigAnalysisGammaHadronCorrelation.C"), "ConfigAnalysisGammaHadronCorrelation.C");
422 TFile::Cp(gSystem->ExpandPathName("$(ALICE_ROOT)/PWG4/macros/ConfigAnalysisPi0.C"), "ConfigAnalysisPi0.C");
423 }
424 // PWG2 task protons
425 if (iPWG2spectra) {
426 if (!LoadLibrary("PWG2spectra", mode, kTRUE)) return kFALSE;
427 }
428 // PWG2 flow
429 if (iPWG2flow) {
430 if (!LoadLibrary("PWG2AOD", mode, kTRUE) ||
431 !LoadLibrary("PWG2flow", mode, kTRUE)) return kFALSE;
432 }
433 // PWG2 resonances
434 if (iPWG2res) {
435 if (!LoadLibrary("PWG2resonances", mode, kTRUE)) return kFALSE;
436 }
437 // PWG2 femtoscopy
438 if (iPWG2femto) {
439 if (!LoadLibrary("PWG2AOD", mode, kTRUE) ||
440 !LoadLibrary("PWG2femtoscopy", mode, kTRUE) ||
441 !LoadLibrary("PWG2femtoscopyUser", mode, kTRUE)) return kFALSE;
442 }
443 // Vertexing HF
444 if (iPWG3vertexing) {
445 if (!LoadLibrary("PWG3vertexingHF", mode, kTRUE)) return kFALSE;
446 }
447 ::Info("LoadAnalysisLibraries", "Load other libraries: SUCCESS");
448 return kTRUE;
449}
450
451//______________________________________________________________________________
452Bool_t LoadLibrary(const char *module, const char *mode, Bool_t rec=kFALSE)
453{
454// Load a module library in a given mode. Reports success.
455 Int_t imode = -1;
456 Int_t result;
457 TString smodule(module);
458 if (!strcmp(mode, "LOCAL")) imode = 0;
459 if (!strcmp(mode, "PROOF")) imode = 1;
460 if (!strcmp(mode, "GRID")) imode = 2;
461 TString mod(module);
462 if (!mod.Length()) {
463 ::Error("LoadLibrary", "Empty module name");
464 return kFALSE;
465 }
466 // If a library is specified, just load it
467 if (smodule.EndsWith(".so")) {
468 mod.Remove(mod.Index(".so"));
469 result = gSystem->Load(mod);
470 if (result < 0) {
471 ::Error("LoadLibrary", "Could not load library %s", module);
472 return kFALSE;
473 }
474 if (rec) anaLibs += Form("%s.so ",mod.Data());
475 return kTRUE;
476 }
477 // Check if the library is already loaded
478 if (strlen(gSystem->GetLibraries(Form("%s.so", module), "", kFALSE)) > 0)
479 return kTRUE;
480 switch (imode) {
481 case 0:
482 case 2:
483 if (usePAR) {
484 result = SetupPar(module);
485 if (rec) anaPars += Form("%s.par ", module);
486 } else {
487 result = gSystem->Load(Form("lib%s.so", module));
488 if (rec) anaLibs += Form("lib%s.so ", module);
489 }
490 break;
491 case 1:
492 result = gProof->UploadPackage(module);
493 if (result<0) {
494 result = gProof->UploadPackage(gSystem->ExpandPathName(Form("$ALICE_ROOT/%s.par", module)));
495 if (result<0) {
496 ::Error("LoadLibrary", "Could not find module %s.par in current directory nor in $ALICE_ROOT", module);
497 return kFALSE;
498 }
499 }
500 result = gProof->EnablePackage(module);
501 break;
502 default:
503 return kFALSE;
504 }
505 if (result < 0) {
506 ::Error("LoadLibrary", "Could not load module %s", module);
507 return kFALSE;
508 }
509 return kTRUE;
510}
511
512
513//______________________________________________________________________________
514TChain *CreateChain(const char *mode, const char *plugin_mode)
515{
516// Create the input chain
517 Int_t imode = -1;
518 if (!strcmp(mode, "LOCAL")) imode = 0;
519 if (!strcmp(mode, "PROOF")) imode = 1;
520 if (!strcmp(mode, "GRID")) imode = 2;
521 TChain *chain = NULL;
522 // Local chain
523 switch (imode) {
524 case 0:
525 if (iAODanalysis) {
526 if (!strlen(dataset)) {
527 // Local AOD
528 chain = new TChain("aodTree");
529 if (gSystem->AccessPathName("AliAOD.root"))
530 ::Error("CreateChain", "File: AliAOD.root not in current dir");
531 else chain->Add("AliAOD.root");
532 } else {
533 // Interactive AOD
534 chain = CreateChainSingle(dataset, "aodTree");
535 }
536 } else {
537 if (!strlen(dataset)) {
538 // Local ESD
539 chain = new TChain("esdTree");
099d8f33 540 if (gSystem->AccessPathName("data/AliESDs.root"))
c6e7c68c 541 ::Error("CreateChain", "File: AliESDs.root not in current dir");
099d8f33 542 else chain->Add("data/AliESDs.root");
c6e7c68c 543 } else {
544 // Interactive ESD
545 chain = CreateChainSingle(dataset, "esdTree");
546 }
547 }
548 break;
549 case 1:
550 break;
551 case 2:
552 if (usePLUGIN) {
553 AliAnalysisGrid *alienHandler = CreateAlienHandler(plugin_mode);
554 AliAnalysisManager::GetAnalysisManager()->SetGridHandler(alienHandler);
555 } else {
556 TString treeName = "esdTree";
557 if (iAODanalysis) treeName = "aodTree";
558 chain = CreateChainSingle("wn.xml", treeName);
559 }
560 break;
561 default:
562 }
563 if (chain && chain->GetNtrees()) return chain;
564 return NULL;
565}
566
567//______________________________________________________________________________
568TChain* CreateChainSingle(const char* xmlfile, const char *treeName)
569{
570 printf("*******************************\n");
571 printf("*** Getting the ESD Chain ***\n");
572 printf("*******************************\n");
573 TAlienCollection * myCollection = TAlienCollection::Open(xmlfile);
574
575 if (!myCollection) {
576 ::Error("CreateChainSingle", "Cannot create an AliEn collection from %s", xmlfile) ;
577 return NULL ;
578 }
579
580 TChain* chain = new TChain(treeName);
581 myCollection->Reset() ;
582 while ( myCollection->Next() ) chain->Add(myCollection->GetTURL("")) ;
583 chain->ls();
584 return chain;
585}
586
587//______________________________________________________________________________
588Int_t SetupPar(char* pararchivename)
589{
590 if (!pararchivename || !strlen(pararchivename)) return -1;
591 char processline[1024];
592 if (gSystem->AccessPathName(Form("%s.par", pararchivename))) {
593 if (!gSystem->AccessPathName(Form("%s/%s.par", gSystem->Getenv("ALICE_ROOT"),pararchivename))) {
594 ::Info("SetupPar", "Getting %s.par from $ALICE_ROOT", pararchivename);
595 TFile::Cp(gSystem->ExpandPathName(Form("$ALICE_ROOT/%s.par", pararchivename)),
596 Form("%s.par",pararchivename));
597 } else {
598 ::Error("SetupPar", "Cannot find %s.par", pararchivename);
599 return -1;
600 }
601 }
602 gSystem->Exec(Form("tar xvzf %s.par", pararchivename));
603
604 TString ocwd = gSystem->WorkingDirectory();
605 if (!gSystem->ChangeDirectory(pararchivename)) return -1;
606
607 // check for BUILD.sh and execute
608 if (!gSystem->AccessPathName("PROOF-INF/BUILD.sh")) {
609 printf("*******************************\n");
610 printf("*** Building PAR archive ***\n");
611 printf("*******************************\n");
612 if (gSystem->Exec("PROOF-INF/BUILD.sh")) {
613 Error("runProcess","Cannot Build the PAR Archive! - Abort!");
614 return -1;
615 }
616 }
617
618 // check for SETUP.C and execute
619 if (!gSystem->AccessPathName("PROOF-INF/SETUP.C")) {
620 printf("*******************************\n");
621 printf("*** Setup PAR archive ***\n");
622 printf("*******************************\n");
623 gROOT->Macro("PROOF-INF/SETUP.C");
624 }
625 if (!gSystem->ChangeDirectory(ocwd.Data())) return -1;
626 return 0;
627}
628
629//______________________________________________________________________________
630AliAnalysisGrid* CreateAlienHandler(const char *plugin_mode)
631{
632// Check if user has a valid token, otherwise make one. This has limitations.
633// One can always follow the standard procedure of calling alien-token-init then
634// source /tmp/gclient_env_$UID in the current shell.
635 if (!AliAnalysisGrid::CreateToken()) return NULL;
636 AliAnalysisAlien *plugin = new AliAnalysisAlien();
637// Set the run mode (can be "full", "test", "offline", "submit" or "terminate")
638 plugin->SetRunMode(plugin_mode);
639 plugin->SetNtestFiles(1);
7ceeacc7 640// plugin->SetPreferedSE("ALICE::NIHAM::FILE");
c6e7c68c 641// Set versions of used packages
642 plugin->SetAPIVersion("V2.4");
643 plugin->SetROOTVersion(root_version);
644 plugin->SetAliROOTVersion(aliroot_version);
645// Declare input data to be processed.
646// Method 1: Create automatically XML collections using alien 'find' command.
647// Define production directory LFN
648 plugin->SetGridDataDir(alien_datadir);
649// Set data search pattern
650 plugin->SetDataPattern("*ESDs.root");
651// ...then add run numbers to be considered
652 for (Int_t i=0; i<10; i++) {
653 if (run_numbers[i]==0) break;
654 plugin->AddRunNumber(run_numbers[i]);
655 }
656// Method 2: Declare existing data files (raw collections, xml collections, root file)
657// If no path mentioned data is supposed to be in the work directory (see SetGridWorkingDir())
658// XML collections added via this method can be combined with the first method if
659// the content is compatible (using or not tags)
660// plugin->AddDataFile("tag.xml");
661// plugin->AddDataFile("/alice/data/2008/LHC08c/000057657/raw/Run57657.Merged.RAW.tag.root");
662// Define alien work directory where all files will be copied. Relative to alien $HOME.
663 plugin->SetGridWorkingDir("analysisESD");
664// Declare alien output directory. Relative to working directory.
665 plugin->SetGridOutputDir("output"); // In this case will be $HOME/work/output
666
667 TString ana_sources = "";
668 TString ana_add = "";
669 if (usePAR && anaPars.Length()) {
670 TObjArray *arr;
671 TObjString *objstr;
672 arr = anaPars.Tokenize(" ");
673 TIter next(arr);
674 while ((objstr=(TObjString*)next())) plugin->EnablePackage(objstr->GetString());
675 delete arr;
676 }
677
678// Declare the analysis source files names separated by blancs. To be compiled runtime
679// using ACLiC on the worker nodes.
680 ana_sources = ana_sources.Strip();
681// Declare all libraries (other than the default ones for the framework. These will be
682// loaded by the generated analysis macro. Add all extra files (task .cxx/.h) here.
683 anaLibs = anaLibs.Strip();
684 if (ana_sources.Length()) plugin->SetAnalysisSource(ana_sources);
685 if (anaLibs.Length()) plugin->SetAdditionalLibs(anaLibs);
686
687// Declare the output file names separated by blancs.
688// (can be like: file.root or file.root@ALICE::Niham::File)
689 plugin->SetDefaultOutputs();
690 plugin->SetMergeExcludes("AliAOD.root");
691// plugin->SetOutputFiles("AliAOD.root");
692// Optionally define the files to be archived.
693// plugin->SetOutputArchive("log_archive.zip:stdout,stderr@ALICE::NIHAM::File root_archive.zip:*.root@ALICE::NIHAM::File");
694 plugin->SetOutputArchive("log_archive.zip:stdout,stderr");
695// Optionally set a name for the generated analysis macro (default MyAnalysis.C)
7ceeacc7 696 plugin->SetAnalysisMacro("AnalysisTrainGrid.C");
c6e7c68c 697// Optionally set maximum number of input files/subjob (default 100, put 0 to ignore)
698 plugin->SetSplitMaxInputFileNumber(50);
699// Optionally set number of failed jobs that will trigger killing waiting sub-jobs.
700// plugin->SetMaxInitFailed(5);
701// Optionally resubmit threshold.
702// plugin->SetMasterResubmitThreshold(90);
703// Optionally set time to live (default 30000 sec)
704 plugin->SetTTL(30000);
705// Optionally set input format (default xml-single)
706 plugin->SetInputFormat("xml-single");
707// Optionally modify the name of the generated JDL (default analysis.jdl)
7ceeacc7 708 plugin->SetJDLName("AnalysisTrain.jdl");
709// Optionally modify the executable name (default analysis.sh)
710 plugin->SetExecutable("AnalysisTrain.sh");
c6e7c68c 711// Optionally modify job price (default 1)
712 plugin->SetPrice(1);
713// Optionally modify split mode (default 'se')
714 plugin->SetSplitMode("se");
715 return plugin;
716}