AliPhysics  8417398 (8417398)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
ana.C
Go to the documentation of this file.
1 
14 //---------------------------------------------------------------------------
16 enum anaModes
17 {
18  mLocal = 0,
19  mPROOF = 1,
20  mPlugin = 2,
21  mGRID = 3
22 };
23 
24 //---------------------------------------------------------------------------
25 // Settings to read locally several files, only for "mLocal" mode
26 // The different values are default, they can be set with environmental
27 // variables: INDIR, PATTERN, NFILES, respectivelly
28 
29 char * kInDir = "/user/data/files/";
30 char * kPattern = "";
31 Int_t kFile = 2;
32 
33 //---------------------------------------------------------------------------
34 // Dataset for proof analysis, mode=mPROOF
35 // char * kDataset = "/alice/vernet/PbPb_LHC10h_ESD";
36 
37 char * kDatasetPROOF = "/alice/vernet/LHC11b_149646";
38 Int_t kDatasetNMaxFiles = 20;
39 TString ccin2p3UserName = "arbor" ;
40 TString alienUserName = "narbor" ;
41 
42 //---------------------------------------------------------------------------
43 // Collection file for grid analysis
44 
45 char * kXML = "collection.xml";
46 
47 //---------------------------------------------------------------------------
48 // Scale histograms from file. Change to kTRUE when xsection file exists
49 // Put name of file containing xsection
50 // Put number of events per ESD file
51 // This is an specific case for normalization of Pythia files.
52 const char * kXSFileName = "pyxsec.root";
53 
54 // Container of xs if xs in file pyxsec_hist.root
55 TArrayF* xsArr;
56 TArrayI* trArr;
57 
58 //---------------------------------------------------------------------------
59 
60 // Set some default values, but used values are set in the code!
61 
62 Bool_t kMC = kFALSE;
63 TString kInputData = "ESD";
64 Int_t kYear = 2011;
65 TString kCollision = "pp";
66 Bool_t outAOD = kFALSE;
67 TString kTreeName;
68 TString kPass = "";
69 char kTrigger[1024];
70 Int_t kRun = 0;
71 
72 //___________________________
85 //___________________________
86 void ana(Int_t mode=mGRID)
87 {
88  //--------------------------------------------------------------------
89  // Load analysis libraries
90 
91  LoadLibraries(mode) ;
92  //gSystem->ListLibraries();
93 
94  //-----------------------------------------------------------------------------
95  // Create chain from ESD and from cross sections files, look below for options.
96 
97  // Set kInputData and kTreeName looking to the kINDIR
98 
99  CheckInputData(mode);
100 
101  // Check global analysis settings
102 
103  CheckEnvironmentVariables();
104 
105  printf("*********************************************\n");
106  printf("*** Input data < %s >, pass %s, tree < %s >, MC? < %d > ***\n",kInputData.Data(),kPass.Data(),kTreeName.Data(),kMC);
107  printf("*********************************************\n");
108 
109  TChain * chain = new TChain(kTreeName) ;
110  TChain * chainxs = new TChain("Xsection") ;
111  CreateChain(mode, chain, chainxs);
112 
113  Double_t scale = -1;
114  printf("===== kMC %d, chainxs %p\n",kMC,chainxs);
115 
116  if(kMC)
117  {
118  //Get the cross section
119  Double_t xsection = 0;
120  Float_t ntrials = 0;
121  Int_t nfiles = 0;
122 
123  Bool_t ok = GetAverageXsection(chainxs, xsection, ntrials, nfiles);
124 
125  printf("n xs files %d",nfiles);
126 
127  if(ok)
128  {
129  Int_t nEventsPerFile = chain->GetEntries() / nfiles;
130 
131  Double_t trials = ntrials / nEventsPerFile ;
132 
133  scale = xsection / trials;
134 
135  printf("Get Cross section : nfiles %d, nevents %d, nevents per file %d \n",nfiles, chain->GetEntries(),nEventsPerFile);
136  printf(" ntrials %d, trials %2.2f, xs %2.2e, scale factor %2.2e\n", ntrials,trials,xsection,scale);
137 
138  if(chainxs->GetEntries()!=chain->GetEntries()) printf("CAREFUL: Number of files in data chain %d, in cross section chain %d \n",
139  chainxs->GetEntries(),chain->GetEntries());
140  } // ok
141 
142  // comment out this line in case the simulation did not have the cross section files produced in the directory
143  if( scale <= 0 || !ok)
144  { printf( "STOP, cross section not available! nfiles %d \n", chainxs->GetEntries() ) ; return ; }
145 
146  }
147 
148  printf("*********************************************\n");
149  printf("number of entries # %lld, skipped %d\n", chain->GetEntries()) ;
150  printf("*********************************************\n");
151 
152  if(!chain)
153  {
154  printf("STOP, no chain available\n");
155  return;
156  }
157 
158  AliLog::SetGlobalLogLevel(AliLog::kError);//Minimum prints on screen
159 
160  //------------------------------------------
161  // Alien handler part
162  //------------------------------------------
163  AliAnalysisGrid *alienHandler=0x0;
164  if(mode==mPlugin)
165  {
166  // Create and configure the alien handler plugin
167  gROOT->LoadMacro("CreateAlienHandler.C");
168  alienHandler = CreateAlienHandler();
169  if (!alienHandler) return;
170  }
171 
172  //--------------------------------------
173  // Make the analysis manager
174  //-------------------------------------
175  AliAnalysisManager *mgr = new AliAnalysisManager("Manager", "Manager");
176  //AliAnalysisManager::SetUseProgressBar(kTRUE);
177  //mgr->SetSkipTerminate(kTRUE);
178  //mgr->SetNSysInfo(1);
179 
180  if(mode==mPlugin)
181  {
182  // Connect plugin to the analysis manager
183  mgr->SetGridHandler(alienHandler);
184  }
185 
186  // MC handler
187  if((kMC || kInputData == "MC") && !kInputData.Contains("AOD"))
188  {
189  AliMCEventHandler* mcHandler = new AliMCEventHandler();
190  mcHandler->SetReadTR(kFALSE);//Do not search TrackRef file
191  mgr->SetMCtruthEventHandler(mcHandler);
192  if( kInputData == "MC")
193  {
194  cout<<"MC INPUT EVENT HANDLER"<<endl;
195  mgr->SetInputEventHandler(NULL);
196  }
197  }
198 
199 
200  // AOD output handler
201  if(kInputData!="deltaAOD" && outAOD)
202  {
203  cout<<"Init output handler"<<endl;
204  AliAODHandler* aodoutHandler = new AliAODHandler();
205  aodoutHandler->SetOutputFileName("aod.root");
207  mgr->SetOutputEventHandler(aodoutHandler);
208  }
209 
210  //input
211 
212  if(kInputData == "ESD")
213  {
214  // ESD handler
215  AliESDInputHandler *esdHandler = new AliESDInputHandler();
216  esdHandler->SetReadFriends(kFALSE);
217  mgr->SetInputEventHandler(esdHandler);
218  cout<<"ESD handler "<<mgr->GetInputEventHandler()<<endl;
219  }
220  else if(kInputData.Contains("AOD"))
221  {
222  // AOD handler
223  AliAODInputHandler *aodHandler = new AliAODInputHandler();
224  mgr->SetInputEventHandler(aodHandler);
225  if(kInputData == "deltaAOD") aodHandler->AddFriend("deltaAODCaloTrackCorr.root");
226  cout<<"AOD handler "<<mgr->GetInputEventHandler()<<endl;
227  }
228 
229  //mgr->RegisterExternalFile("deltaAODCaloTrackCorr.root");
230  //mgr->SetDebugLevel(1); // For debugging, do not uncomment if you want no messages.
231 
232  TString outputFile = AliAnalysisManager::GetCommonFileName();
233 
234  //-------------------------------------------------------------------------
235  // Define task, put here any other task that you want to use.
236  //-------------------------------------------------------------------------
237 
238  // Physics selection
239  if(kInputData=="ESD" && !kMC)
240  {
241  gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C");
242  AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(kMC);
243  }
244 
245  // Centrality, valid for Run1, but superseeded by new task below
246  if(kCollision=="PbPb" && kInputData=="ESD" && kRun < 200000)
247  {
248  gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskCentrality.C");
249  AliCentralitySelectionTask *taskCentrality = AddTaskCentrality();
250  }
251 
252  {
253  // New centrality/multiplicity selector
254  gROOT->LoadMacro("$ALICE_PHYSICS/OADB/COMMON/MULTIPLICITY/macros/AddTaskMultSelection.C");
255  AliMultSelectionTask * task = AddTaskMultSelection(kFALSE); // user mode:
256 
257  //use the default calibration for runs which have not yet been calibrated
258  task->SetUseDefaultCalib(kTRUE); // data
259  task->SetUseDefaultMCCalib(kTRUE); // MC
260  }
261 
262  if(kCollision=="PbPb")
263  {
264  gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskVZEROEPSelection.C");
265  AliVZEROEPSelectionTask * EPV0 = AddTaskVZEROEPSelection();
266 
267  gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskEventplane.C");
268  AliEPSelectionTask * EP = AddTaskEventplane();
269  }
270 
271 
272 
273  // Simple event counting tasks
274 
275  gROOT->LoadMacro("$ALICE_PHYSICS/PWGGA/CaloTrackCorrelations/macros/AddTaskCounter.C");
276 
277  AliAnalysisTask* count = AddTaskCounter("",kMC); // All, fill histo with cross section and trials if kMC is true
278  AliAnalysisTask* countmb = AddTaskCounter("MB"); // Min Bias
279  AliAnalysisTask* countany = AddTaskCounter("Any");
280  AliAnalysisTask* countint = AddTaskCounter("AnyINT");// Min Bias
281 
282  if(!kMC)
283  {
284  AliAnalysisTaskCounter* countemg = AddTaskCounter("EMCEGA");
285  AliAnalysisTaskCounter* countemj = AddTaskCounter("EMCEJE");
286  if(kCollision=="PbPb")
287  {
288  AliAnalysisTaskCounter* countcen = AddTaskCounter("Central");
289  AliAnalysisTaskCounter* countsce = AddTaskCounter("SemiCentral");
290  AliAnalysisTaskCounter* countssce= AddTaskCounter("SemiOrCentral");
291  AliAnalysisTaskCounter* countphP = AddTaskCounter("PHOSPb");
292  }
293  else
294  {
295  AliAnalysisTaskCounter* countem1 = AddTaskCounter("EMC1"); // Trig Th > 1.5 GeV approx
296  AliAnalysisTaskCounter* countem7 = AddTaskCounter("EMC7"); // Trig Th > 4-5 GeV
297  AliAnalysisTaskCounter* countphp = AddTaskCounter("PHOS");
298  }
299  }
300  // -----------------
301  // Photon conversion
302  // -----------------
303 /*
304  if(kInputData=="ESD"){
305  printf("* Configure photon conversion analysis in macro \n");
306  TString arguments = "-run-on-train -use-own-xyz -force-aod -mc-off ";
307  gROOT->LoadMacro("$ALICE_PHYSICS/PWGGA/GammaConversion/macros/ConfigGammaConversion.C");
308  AliAnalysisTaskGammaConversion * taskGammaConversion =
309  ConfigGammaConversion(arguments,mgr->GetCommonInputContainer());
310  taskGammaConversion->SelectCollisionCandidates();
311 
312  // Gamma Conversion AOD to AODPWG4Particle
313  AliAnalysisTaskGCPartToPWG4Part * taskGCToPC = new AliAnalysisTaskGCPartToPWG4Part("GCPartToPWG4Part");
314  taskGCToPC->SetGammaCutId("90035620401003321022000000090");
315  mgr->AddTask(taskGCToPC);
316  mgr->ConnectInput (taskGCToPC, 0, mgr->GetCommonInputContainer() );
317  mgr->ConnectOutput (taskGCToPC, 0, mgr->GetCommonOutputContainer());
318  }
319 */
320 
321  Bool_t kPrint = kFALSE;
322  Bool_t deltaAOD = kFALSE;
323  gROOT->LoadMacro("AddTaskCaloTrackCorr.C"); // $ALICE_PHYSICS/PWGGA/CaloTrackCorrelations/macros
324  gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/EMCAL/macros/AddTaskEMCALClusterize.C");
325 
326  //gROOT->LoadMacro("$ALICE_PHYSICS/PWGGA/CaloTrackCorrelations/macros/QA/AddTaskCalorimeterQA.C");
327  //AliAnalysisTaskCaloTrackCorrelation * qatask = AddTaskCalorimeterQA(kInputData,kYear,kPrint,kMC);
328 
329  //gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/EMCAL/macros/AddTaskEMCALTriggerQA.C");
330  //AliAnalysisTaskEMCALTriggerQA * qatrigtask = AddTaskEMCALTriggerQA();
331 
332  // Calibration, bad map ...
333 
334  Bool_t calibEE = kTRUE; // It is set automatically, but here we force to use it or not in any case
335  Bool_t calibTT = kTRUE; // It is set automatically, but here we force to use it or not in any case
336  if(kRun < 122195 || (kRun > 126437 && kRun < 136851) || kMC) calibTT=kFALSE ; // Recalibration parameters not available for LHC10a,b,c,e,f,g
337  Bool_t badMap = kTRUE; // It is set automatically, but here we force to use it or not in any case
338 
339  if(kCollision=="pp")
340  {
341  printf("==================================== \n");
342  printf("CONFIGURE ANALYSIS FOR PP COLLISIONS \n");
343  printf("==================================== \n");
344 
345  Bool_t mixing = kTRUE; // mixing in reader and hadron correlation, and pi0
346  Bool_t clTM = kTRUE;
347  Bool_t reTM = kFALSE; // Recalculate matches if not already done in clusterizer
348  Bool_t anTM = kTRUE; // Remove matched
349  Bool_t exo = kTRUE; // Remove exotic cells
350  Bool_t clnonlin = kTRUE; // Apply non linearity (clusterization)
351  Bool_t annonlin = kFALSE; // Apply non linearity (analysis)
352  Int_t minEcell = 50; // 50 MeV (10 MeV used in reconstruction)
353  Int_t minEseed = 100; // 100 MeV
354  Int_t dTime = 0; // default, 250 ns
355  Int_t wTime = 30; // default 425 < T < 825 ns, careful if time calibration is on
356  Int_t unfMinE = 15; // Remove cells with less than 15 MeV from cluster after unfolding
357  Int_t unfFrac = 1; // Remove cells with less than 1% of cluster energy after unfolding
358 
359  //Trigger
360  TString clTrigger = "";
361  TString anTrigger = "EMC7";
362 
363  if(kMC)
364  {
365  clTrigger = "";
366  anTrigger = "";
367  dTime = 0;
368  wTime = 0;
369  }
370 
371  Bool_t selectEvents = kFALSE; // Select events depending on V0, pile-up and vertex quality
372  Bool_t qa = kTRUE; // Do besides calorimeter QA analysis
373  Bool_t hadron = kTRUE; // Do besides charged track correlations analysis
374 
375  //Analysis with clusterizer V1
376 
377  TString arrayNameV1 = "";
378 
379  AliAnalysisTaskEMCALClusterize * clv1 = AddTaskEMCALClusterize(arrayNameV1,outAOD,kMC,exo,"V1",clTrigger, clTM,
380  minEcell,minEseed,dTime,wTime,unfMinE,unfFrac,
381  calibEE,badMap,calibTT,clnonlin);
382 
383  printf("Name of clusterizer1 array: %s\n",arrayNameV1.Data());
384 
385  if(!kMC)
386  {
387 
388  AliAnalysisTaskCaloTrackCorrelation *anav1trig = AddTaskCaloTrackCorr(kInputData, "EMCAL", kMC, selectEvents, exo, annonlin, outputFile.Data(),
389  kYear,kCollision,anTrigger,arrayNameV1,mixing,reTM,anTM,
390  -1,-1, qa, hadron,calibEE,badMap,calibTT,deltaAOD,kPrint,scale,kRun);
391  }
392 
393  AliAnalysisTaskCaloTrackCorrelation *anav1mb = AddTaskCaloTrackCorr(kInputData, "EMCAL", kMC, selectEvents, exo, annonlin, outputFile.Data(),
394  kYear,kCollision,"AnyINT",arrayNameV1,mixing,reTM,anTM,
395  -1,-1, qa, hadron,calibEE,badMap,calibTT,deltaAOD,kPrint,scale,kRun);
396 
397 
398 
399  //Analysis with clusterizer V2
400  TString arrayNameV2 = "";
401  AliAnalysisTaskEMCALClusterize * clv2 = AddTaskEMCALClusterize(arrayNameV2,outAOD,kMC,exo,"V2",clTrigger, clTM,
402  minEcell,minEseed,dTime,wTime,
403  calibEE,badMap,calibTT,clnonlin);
404 
405  printf("Name of clusterizer2 array: %s\n",arrayNameV2.Data());
406 
407  hadron = kFALSE;
408  if(!kMC)
409  {
410 
411 
412  AliAnalysisTaskCaloTrackCorrelation *anav2tr = AddTaskCaloTrackCorr(kInputData, "EMCAL", kMC, selectEvents, exo, annonlin, outputFile.Data(),
413  kYear,kCollision,anTrigger,arrayNameV2,mixing,reTM,anTM,
414  -1,-1,qa,hadron,calibEE,badMap,calibTT,deltaAOD,kPrint,scale,kRun);
415  }
416 
417 
418  AliAnalysisTaskCaloTrackCorrelation *anav2mb = AddTaskCaloTrackCorr(kInputData, "EMCAL", kMC, selectEvents, exo, annonlin, outputFile.Data(),
419  kYear,kCollision,"AnyINT",arrayNameV2,mixing,reTM,anTM,
420  -1,-1, qa, hadron,calibEE,badMap,calibTT,deltaAOD,kPrint,scale,kRun);
421  }
422 
423  if(kCollision=="PbPb")
424  {
425  printf("====================================== \n");
426  printf("CONFIGURE ANALYSIS FOR PbPb COLLISIONS \n");
427  printf("====================================== \n");
428  Bool_t mixing = kTRUE;
429  Bool_t clTM = kTRUE;
430  Bool_t reTM = kFALSE; // Recalculate matches if not already done in clusterizer
431  Bool_t anTM = kTRUE; // Remove matched
432  Bool_t exo = kTRUE; // Remove exotic cells
433  Bool_t clnonlin = kTRUE; // Apply non linearity (clusterization)
434  Bool_t annonlin = kFALSE; // Apply non linearity (analysis)
435  Int_t minEcell = 150; // 50 MeV (10 MeV used in reconstruction)
436  Int_t minEseed = 300; // 100 MeV
437  Int_t dTime = 0; // default, 250 ns
438  Int_t wTime = 0; // default 425 < T < 825 ns
439  Int_t unfMinE = 15; // Remove cells with less than 15 MeV from cluster after unfolding
440  Int_t unfFrac = 1; // Remove cells with less than 1% of cluster energy after unfolding
441 
442  // Trigger
443  TString clTrigger = "";
444  TString anTrigger = "EMCGA";
445  if(kMC)
446  {
447  clTrigger = "";
448  anTrigger = "";
449  dTime = 0;
450  wTime = 0;
451  }
452 
453  Bool_t selectEvents = kFALSE; // Select events depending on V0, pile-up and vertex quality
454  Bool_t qa = kTRUE; // Do besides calorimeter QA analysis
455  Bool_t hadron = kTRUE; // Do besides charged track correlations analysis
456 
457  //Analysis with clusterizer V1
458 
459  TString arrayNameV1 = "";
460  AliAnalysisTaskEMCALClusterize * clv1 = AddTaskEMCALClusterize(arrayNameV1,outAOD,kMC,exo,"V1",clTrigger, clTM,
461  minEcell,minEseed,dTime,wTime,unfMinE,unfFrac,
462  calibEE,badMap,calibTT,clnonlin);
463 
464  printf("Name of clusterizer1 array: %s\n",arrayNameV1.Data());
465 
466  if(!kMC)
467  {
468  AliAnalysisTaskCaloTrackCorrelation *anav1c = AddTaskCaloTrackCorr(kInputData, "EMCAL", kMC, selectEvents, exo, annonlin, outputFile.Data(),
469  kYear,kCollision,anTrigger,arrayNameV1,mixing,reTM,anTM,
470  0,20,qa,hadron,calibEE,badMap,calibTT,deltaAOD,kPrint,scale,kRun);
471  AliAnalysisTaskCaloTrackCorrelation *anav1m = AddTaskCaloTrackCorr(kInputData, "EMCAL", kMC, selectEvents, exo, annonlin, outputFile.Data(),
472  kYear,kCollision,anTrigger,arrayNameV1,mixing,reTM,anTM,
473  20,40,qa,hadron,calibEE,badMap,calibTT,deltaAOD,kPrint,scale,kRun);
474  AliAnalysisTaskCaloTrackCorrelation *anav1p = AddTaskCaloTrackCorr(kInputData, "EMCAL", kMC, selectEvents, exo, annonlin, outputFile.Data(),
475  kYear,kCollision,anTrigger,arrayNameV1,mixing,reTM,anTM,
476  60,80,qa,hadron,calibEE,badMap,calibTT,deltaAOD,kPrint,scale,kRun);
477  }
478 
479  //Analysis with clusterizer V2
480 
481  TString arrayNameV2 = "";
482  AliAnalysisTaskEMCALClusterize * clv2 = AddTaskEMCALClusterize(arrayNameV2,outAOD,kMC,exo,"V2",clTrigger, clTM,
483  minEcell,minEseed,dTime,wTime,unfMinE,unfFrac,
484  calibEE,badMap,calibTT,clnonlin);
485 
486  printf("Name of clusterizer2 array: %s\n",arrayNameV2.Data());
487 
488  hadron = kFALSE;
489 
490  if(!kMC)
491  {
492 
493  AliAnalysisTaskCaloTrackCorrelation *anav2cT = AddTaskCaloTrackCorr(kInputData, "EMCAL", kMC, selectEvents, exo, annonlin, outputFile.Data(),
494  kYear,kCollision,anTrigger,arrayNameV2,mixing,reTM,anTM,
495  0,20,qa,hadron,calibEE,badMap,calibTT,deltaAOD,kPrint,scale,kRun);
496  AliAnalysisTaskCaloTrackCorrelation *anav2mT = AddTaskCaloTrackCorr(kInputData, "EMCAL", kMC, selectEvents, exo, annonlin, outputFile.Data(),
497  kYear,kCollision,anTrigger,arrayNameV2,mixing,reTM,anTM,
498  20,40,qa,hadron,calibEE,badMap,calibTT,deltaAOD,kPrint,scale,kRun);
499  AliAnalysisTaskCaloTrackCorrelation *anav2pT = AddTaskCaloTrackCorr(kInputData, "EMCAL", kMC, selectEvents, exo, annonlin, outputFile.Data(),
500  kYear,kCollision,anTrigger,arrayNameV2,mixing,reTM,anTM,
501  60,80,qa,hadron,calibEE,badMap,calibTT,deltaAOD,kPrint,scale,kRun);
502  }
503 
504  AliAnalysisTaskCaloTrackCorrelation *anav2cMB = AddTaskCaloTrackCorr(kInputData, "EMCAL", kMC, selectEvents, exo, annonlin, outputFile.Data(),
505  kYear,kCollision,"AnyINT",arrayNameV2,mixing,reTM,anTM,
506  0,20,qa,hadron,calibEE,badMap,calibTT,deltaAOD,kPrint,scale,kRun);
507  AliAnalysisTaskCaloTrackCorrelation *anav2mMB = AddTaskCaloTrackCorr(kInputData, "EMCAL", kMC, selectEvents, exo, annonlin, outputFile.Data(),
508  kYear,kCollision,"AnyINT",arrayNameV2,mixing,reTM,anTM,
509  20,40,qa,hadron,calibEE,badMap,calibTT,deltaAOD,kPrint,scale,kRun);
510  AliAnalysisTaskCaloTrackCorrelation *anav2pMB = AddTaskCaloTrackCorr(kInputData, "EMCAL", kMC, selectEvents, exo, annonlin, outputFile.Data(),
511  kYear,kCollision,"AnyINT",arrayNameV2,mixing,reTM,anTM,
512  60,80,qa,hadron,calibEE,badMap,calibTT,deltaAOD,kPrint,scale,kRun);
513 
514 
515  }
516 
517  //-----------------------
518  // Run the analysis
519  //-----------------------
520  mgr->InitAnalysis();
521  mgr->PrintStatus();
522 
523  if (mode == mPlugin) mgr->StartAnalysis("grid");
524  else if (mode == mPROOF ) mgr->StartAnalysis("proof",chain);
525  else mgr->StartAnalysis("local",chain);
526 
527  cout <<" Analysis ended sucessfully "<< endl ;
528 }
529 
530 //_____________________________
532 //_____________________________
533 void LoadLibraries(Int_t mode)
534 {
535  if (mode == mPROOF)
536  {
537  //TProof::Mgr("ccalpmaster")->SetROOTVersion("ALICE_v5-27-06b");
538  gROOT->LoadMacro("/afs/in2p3.fr/group/alice/laf/EnableAliRootForLAF.C");
539  TProof* proof = EnableAliRootForLAF("ccaplmaster",nPROOFWorkers.Data(),ccin2p3UserName.Data(),alienUserName.Data(),"",kFALSE,kTRUE,kTRUE,"OADB:ANALYSIS:ANALYSISalice:AOD:ESD:CORRFW:STEERBase:EMCALUtils:PHOSUtils:PWGCaloTrackCorrBase:PWGGACaloTrackCorrelations:PWGPPEMCAL");
540 
541  // TProof* proof = TProof::Open("ccaplmaster",Form("workers=%s",nPROOFWorkers.Data()));
542 
543  // //proof->ClearPackages();
544  // proof->UploadPackage("STEERBase");
545  // proof->UploadPackage("ESD");
546  // proof->UploadPackage("AOD");
547  // proof->UploadPackage("ANALYSIS");
548  // proof->UploadPackage("OADB");
549  // proof->UploadPackage("ANALYSISalice");
550  // proof->UploadPackage("CORRFW");
551  // //proof->UploadPackage("JETAN");
552  // proof->UploadPackage("PHOSUtils");
553  // proof->UploadPackage("EMCALUtils");
554  // proof->UploadPackage("PWGCaloTrackCorrBase");
555  // proof->UploadPackage("PWGGACaloTrackCorrelations");
556  // proof->UploadPackage("PWGPPEMCAL");
557 
558  // proof->EnablePackage("STEERBase");
559  // proof->EnablePackage("ESD");
560  // proof->EnablePackage("AOD");
561  // proof->EnablePackage("ANALYSIS");
562  // proof->EnablePackage("OADB");
563  // proof->EnablePackage("ANALYSISalice");
564  // proof->EnablePackage("CORRFW");
565  // //proof->EnablePackage("JETAN");
566  // proof->EnablePackage("PHOSUtils");
567  // proof->EnablePackage("EMCALUtils");
568  // proof->EnablePackage("PWGCaloTrackCorrBase");
569  // proof->EnablePackage("PWGGACaloTrackCorrelations");
570  // proof->EnablePackage("PWGPPEMCAL");
571  return;
572  }
573 
574  //--------------------------------------
575  // Load the needed libraries most of them already loaded by aliroot
576  //--------------------------------------
577  gSystem->Load("libTree");
578  gSystem->Load("libGeom");
579  gSystem->Load("libVMC");
580  gSystem->Load("libXMLIO");
581  gSystem->Load("libMatrix");
582  gSystem->Load("libPhysics");
583  gSystem->Load("libMinuit"); // Root + libraries to if reclusterization is done
584 
585  gSystem->Load("libSTEERBase");
586  gSystem->Load("libGui"); // Root + libraries to if reclusterization is done
587  gSystem->Load("libCDB"); // Root + libraries to if reclusterization is done
588  gSystem->Load("libESD"); // Root + libraries to if reclusterization is done
589  gSystem->Load("libAOD");
590  gSystem->Load("libRAWDatabase"); // Root + libraries to if reclusterization is done
591  gSystem->Load("libProof");
592  gSystem->Load("libOADB");
593  gSystem->Load("libANALYSIS");
594  gSystem->Load("libSTEER"); // Root + libraries to if reclusterization is done
595 
596  gSystem->Load("libRAWDatarec"); // Root + libraries to if reclusterization is done
597  gSystem->Load("libRAWDatasim"); // Root + libraries to if reclusterization is done
598  gSystem->Load("libVZERObase"); // Root + libraries to if reclusterization is done
599  gSystem->Load("libVZEROrec"); // Root + libraries to if reclusterization is done
600 
601  gSystem->Load("libPHOSUtils");
602 
603  gSystem->Load("libEMCALUtils");
604  //SetupPar("EMCALUtils");
605  gSystem->Load("libEMCALraw"); // Root + libraries to if reclusterization is done
606  gSystem->Load("libEMCALbase"); // Root + libraries to if reclusterization is done
607  gSystem->Load("libEMCALsim"); // Root + libraries to if reclusterization is done
608  gSystem->Load("libEMCALrec"); // Root + libraries to if reclusterization is done
609  //SetupPar("EMCALraw");
610  //SetupPar("EMCALbase");
611  //SetupPar("EMCALsim");
612  //SetupPar("EMCALrec");
613 
614  gSystem->Load("libANALYSISalice");
615  gSystem->Load("libESDfilter");
616 
617  gSystem->Load("libTender");
618  gSystem->Load("libTenderSupplies");
619 
620  gSystem->Load("libCORRFW");
621  gSystem->Load("libPWGTools");
622 
623  gSystem->Load("libPWGPPEMCAL");
624  //SetupPar("PWGPPEMCAL");
625 
626  gSystem->Load("libPWGCaloTrackCorrBase");
627  gSystem->Load("libPWGGACaloTrackCorrelations");
628  //SetupPar("PWGCaloTrackCorrBase");
629  //SetupPar("PWGGACaloTrackCorrelations");
630 
631  //gSystem->Load("libJETAN");
632  //gSystem->Load("FASTJETAN");
633  //gSystem->Load("PWGJE");
634 
635  //gSystem->Load("libCORRFW");
636  //gSystem->Load("libPWGGAGammaConv");
637  //SetupPar("PWGGAGammaConv");
638 
639  // needed for plugin?
640  gSystem->AddIncludePath("-I$ALICE_ROOT");
641  gSystem->AddIncludePath("-I$ALICE_PHYSICS");
642  gSystem->AddIncludePath("-I./");
643 }
644 
645 //_________________________________
649 //_________________________________
650 void SetupPar(char* pararchivename)
651 {
652  TString cdir(Form("%s", gSystem->WorkingDirectory() )) ;
653 
654  TString parpar(Form("%s.par", pararchivename)) ;
655 
656  if ( gSystem->AccessPathName(pararchivename) )
657  {
658  TString processline = Form(".! tar xvzf %s",parpar.Data()) ;
659  gROOT->ProcessLine(processline.Data());
660  }
661 
662  TString ocwd = gSystem->WorkingDirectory();
663  gSystem->ChangeDirectory(pararchivename);
664 
665  // check for BUILD.sh and execute
666  if (!gSystem->AccessPathName("PROOF-INF/BUILD.sh"))
667  {
668  printf("*******************************\n");
669  printf("*** Building PAR archive ***\n");
670  cout<<pararchivename<<endl;
671  printf("*******************************\n");
672 
673  if (gSystem->Exec("PROOF-INF/BUILD.sh"))
674  {
675  Error("runProcess","Cannot Build the PAR Archive! - Abort!");
676  return -1;
677  }
678  }
679  // check for SETUP.C and execute
680  if (!gSystem->AccessPathName("PROOF-INF/SETUP.C"))
681  {
682  printf("*******************************\n");
683  printf("*** Setup PAR archive ***\n");
684  cout<<pararchivename<<endl;
685  printf("*******************************\n");
686  gROOT->Macro("PROOF-INF/SETUP.C");
687  }
688 
689  gSystem->ChangeDirectory(ocwd.Data());
690  printf("Current dir: %s\n", ocwd.Data());
691 }
692 
693 //______________________________________
695 //______________________________________
696 void CheckInputData(const anaModes mode)
697 {
698  TString ocwd = gSystem->WorkingDirectory();
699 
700  //---------------------------------------
701  // Local files analysis
702  //---------------------------------------
703  if(mode == mLocal){
704  //If you want to add several ESD files sitting in a common directory INDIR
705  //Specify as environmental variables the directory (INDIR), the number of files
706  //to analyze (NFILES) and the pattern name of the directories with files (PATTERN)
707 
708  if(gSystem->Getenv("INDIR"))
709  kInDir = gSystem->Getenv("INDIR") ;
710  else cout<<"INDIR not set, use default: "<<kInDir<<endl;
711 
712  TString sindir(kInDir);
713  if (sindir.Contains("pass1")) kPass = "pass1";
714  else if(sindir.Contains("pass2")) kPass = "pass2";
715  else if(sindir.Contains("pass3")) kPass = "pass3";
716 
717  if(gSystem->Getenv("PATTERN"))
718  kPattern = gSystem->Getenv("PATTERN") ;
719  else cout<<"PATTERN not set, use default: "<<kPattern<<endl;
720 
721  cout<<"INDIR : "<<kInDir<<endl;
722  cout<<"NFILES : "<<kFile<<endl;
723 
724  char fileE[120] ;
725  char fileA[120] ;
726  char fileG[120] ;
727  char fileEm[120] ;
728  for (Int_t event = 0 ; event < kFile ; event++) {
729  sprintf(fileE, "%s/%s%d/AliESDs.root", kInDir,kPattern,event) ;
730  sprintf(fileA, "%s/%s%d/AliAOD.root", kInDir,kPattern,event) ;
731  sprintf(fileG, "%s/%s%d/galice.root", kInDir,kPattern,event) ;
732  sprintf(fileEm, "%s/%s%d/embededAOD.root", kInDir,kPattern,event) ;
733 
734  TFile * fESD = TFile::Open(fileE) ;
735  TFile * fAOD = TFile::Open(fileA) ;
736 
737  //Check if file exists and add it, if not skip it
738  if (fESD)
739  {
740  kTreeName = "esdTree";
741  kInputData = "ESD";
742  TFile * fG = TFile::Open(fileG);
743  if(fG) { kMC = kTRUE; fG->Close();}
744  else kMC = kFALSE;
745 
746  // Get run number
747  TTree* esdTree = (TTree*)fESD->Get("esdTree");
748  AliESDEvent* esd = new AliESDEvent();
749  esd->ReadFromTree(esdTree);
750  esdTree->GetEvent(0);
751  kRun = esd->GetRunNumber();
752 
753  return;
754  }
755  else if(fAOD)
756  {
757  kTreeName = "aodTree";
758  kInputData = "AOD";
759  if(((TTree*) fAOD->Get("aodTree"))->GetBranch("mcparticles")) kMC=kTRUE;
760  else kMC = kFALSE;
761 
762  // Get run number
763  TTree* aodTree = (TTree*)fAOD->Get("aodTree");
764  AliAODEvent* aod = new AliAODEvent();
765  aod->ReadFromTree(aodTree);
766  aodTree->GetEvent(0);
767  kRun = aod->GetRunNumber();
768  return;
769  }
770  else if(TFile::Open(fileEm))
771  {
772  kTreeName = "aodTree";
773  kInputData = "AOD";
774  kMC = kTRUE;
775 
776  return;
777  }
778  else if(TFile::Open(fileG))
779  {
780  kTreeName = "TE";
781  kInputData = "MC";
782  kMC = kTRUE;
783  return;
784  }
785  }
786 
787  if(fESD) fESD->Close();
788  if(fAOD) fAOD->Close();
789 
790  }// local files analysis
791 
792  //------------------------------
793  //GRID xml files
794  //-----------------------------
795  else if(mode == mGRID){
796  //Get colection file. It is specified by the environmental
797  //variable XML
798 
799  if(gSystem->Getenv("XML") )
800  kXML = gSystem->Getenv("XML");
801  else
802  sprintf(kXML, "collection.xml") ;
803 
804  if (!TFile::Open(kXML)) {
805  printf("No collection file with name -- %s -- was found\n",kXML);
806  return ;
807  }
808  else cout<<"XML file "<<kXML<<endl;
809 
810  //Load necessary libraries and connect to the GRID
811  gSystem->Load("libNetx") ;
812  gSystem->Load("libRAliEn");
813  TGrid::Connect("alien://") ;
814 
815  //Feed Grid with collection file
816  TGridCollection * collection = (TGridCollection*) TAlienCollection::Open(kXML);
817  if (! collection) {
818  AliError(Form("%s not found", kXML)) ;
819  return kFALSE ;
820  }
821  TGridResult* result = collection->GetGridResult("",0 ,0);
822 
823  for (Int_t index = 0; index < result->GetEntries(); index++) {
824  TString alienURL = result->GetKey(index, "turl") ;
825  cout << "================== " << alienURL << endl ;
826 
827  if (alienURL.Contains("pass1")) kPass = "pass1";
828  else if(alienURL.Contains("pass2")) kPass = "pass2";
829  else if(alienURL.Contains("pass3")) kPass = "pass3";
830 
831  kRun = AliAnalysisManager::GetRunFromAlienPath(alienURL.Data());
832  printf("Run number from alien path = %d\n",kRun);
833 
834  TFile * fAOD = 0 ;
835  //Check if file exists and add it, if not skip it
836  if (alienURL.Contains("AliESDs.root"))
837  {
838  kTreeName = "esdTree";
839  kInputData = "ESD";
840  alienURL.ReplaceAll("AliESDs.root","galice.root");
841  if(TFile::Open(alienURL)) kMC=kTRUE;
842  else kMC = kFALSE;
843  return;
844  }
845  else if(alienURL.Contains("AliAOD.root"))
846  {
847  kTreeName = "aodTree";
848  kInputData = "AOD";
849  fAOD = TFile::Open(alienURL);
850  if(((TTree*) fAOD->Get("aodTree"))->GetBranch("mcparticles")) kMC=kTRUE;
851  else kMC = kFALSE;
852  return;
853  }
854  else if(alienURL.Contains("embededAOD.root"))
855  {
856  kTreeName = "aodTree";
857  kInputData = "AOD";
858  kMC=kTRUE;
859  return;
860  }
861  else if(alienURL.Contains("galice.root"))
862  {
863  kTreeName = "TE";
864  kInputData = "MC";
865  kMC=kTRUE;
866  return;
867  }
868  }
869  }// xml analysis
870  //------------------------------
871  //PROOF files
872  //-----------------------------
873  else if(mode == mPROOF){
874 
875  TFileCollection* coll = gProof->GetDataSet(kDatasetPROOF)->GetStagedSubset();
876 
877  TIter iter(coll->GetList());
878 
879  TFileInfo* fileInfo = 0;
880  while ((fileInfo = dynamic_cast<TFileInfo*> (iter())))
881  {
882  if (fileInfo->GetFirstUrl()) {
883  TString ProofURL = fileInfo->GetFirstUrl()->GetUrl();
884  cout << "================== " << ProofURL << endl ;
885 
886  if (ProofURL.Contains("pass1")) kPass = "pass1";
887  else if(ProofURL.Contains("pass2")) kPass = "pass2";
888  else if(ProofURL.Contains("pass3")) kPass = "pass3";
889 
890  kRun = AliAnalysisManager::GetRunFromAlienPath(ProofURL.Data());
891  printf("Run number from alien path = %d\n",kRun);
892 
893  TFile * fAOD = 0 ;
894  //Check if file exists and add it, if not skip it
895  if (ProofURL.Contains("AliESDs.root"))
896  {
897  kTreeName = "esdTree";
898  kInputData = "ESD";
899  alienURL.ReplaceAll("AliESDs.root","galice.root");
900  if(TFile::Open(ProofURL)) kMC=kTRUE;
901  else kMC = kFALSE;
902 
903  return;
904  }
905  else if(ProofURL.Contains("AliAOD.root"))
906  {
907  kTreeName = "aodTree";
908  kInputData = "AOD";
909  fAOD = TFile::Open(ProofURL);
910  if(((TTree*) fAOD->Get("aodTree"))->GetBranch("mcparticles")) kMC=kTRUE;
911  else kMC = kFALSE;
912  return;
913  }
914  else if(ProofURL.Contains("embededAOD.root"))
915  {
916  kTreeName = "aodTree";
917  kInputData = "AOD";
918  kMC=kTRUE;
919  return;
920  }
921  else if(ProofURL.Contains("galice.root"))
922  {
923  kTreeName = "TE";
924  kInputData = "MC";
925  kMC=kTRUE;
926  return;
927  }
928  }
929  }
930  }// proof analysis
931 
932  gSystem->ChangeDirectory(ocwd.Data());
933 }
934 
935 //_____________________________________________________________________
937 //_____________________________________________________________________
938 void CreateChain(const anaModes mode, TChain * chain, TChain * chainxs)
939 {
940  TString ocwd = gSystem->WorkingDirectory();
941 
942  if(kInputData == "AOD")
943  {
944  xsArr = new TArrayF;
945  trArr = new TArrayI;
946  }
947 
948  //---------------------------------------
949  // Local files analysis
950  //---------------------------------------
951  if(mode == mLocal)
952  {
953  //If you want to add several ESD files sitting in a common directory INDIR
954  //Specify as environmental variables the directory (INDIR), the number of files
955  //to analyze (NFILES) and the pattern name of the directories with files (PATTERN)
956 
957  if(gSystem->Getenv("INDIR"))
958  kInDir = gSystem->Getenv("INDIR") ;
959  else cout<<"INDIR not set, use default: "<<kInDir<<endl;
960 
961  if(gSystem->Getenv("PATTERN"))
962  kPattern = gSystem->Getenv("PATTERN") ;
963  else cout<<"PATTERN not set, use default: "<<kPattern<<endl;
964 
965  if(gSystem->Getenv("NFILES"))
966  kFile = atoi(gSystem->Getenv("NFILES")) ;
967  else cout<<"NFILES not set, use default: "<<kFile<<endl;
968 
969  //Check if env variables are set and are correct
970  if ( kInDir && kFile)
971  {
972  printf("Get %d files from directory %s\n",kFile,kInDir);
973  if ( ! gSystem->cd(kInDir) )
974  {//check if ESDs directory exist
975  printf("%s does not exist\n", kInDir) ;
976  return ;
977  }
978 
979  //if(gSystem->Getenv("XSFILE"))
980  //kXSFileName = gSystem->Getenv("XSFILE") ;
981  //else cout<<" XS file name not set, use default: "<<kXSFileName<<endl;
982  char * kGener = gSystem->Getenv("GENER");
983  if(kGener)
984  {
985  cout<<"GENER "<<kGener<<endl;
986  if (!strcmp(kGener,"PYTHIA")) kXSFileName = "pyxsec.root";
987  else if(!strcmp(kGener,"HERWIG")) kXSFileName = "hexsec.root";
988  else cout<<" UNKNOWN GENER, use default: "<<kXSFileName<<endl;
989  }
990  else cout<<" GENER not set, use default xs file name: "<<kXSFileName<<endl;
991 
992  if(kInputData=="AOD")
993  {
994  kXSFileName = "pyxsec_hists.root";
995  xsArr->Set(kFile);
996  trArr->Set(kFile);
997  }
998 
999  cout<<"INDIR : "<<kInDir <<endl;
1000  cout<<"NFILES : "<<kFile <<endl;
1001  cout<<"PATTERN : "<<kPattern <<endl;
1002  cout<<"XSFILE : "<<kXSFileName<<endl;
1003 
1004  TString datafile="";
1005  if (kInputData == "ESD") datafile = "AliESDs.root" ;
1006  else if(kInputData.Contains("AOD")) datafile = "AliAOD.root" ;
1007  else if(kInputData == "MC") datafile = "galice.root" ;
1008 
1009  // Loop on ESD/AOD/MC files, add them to chain
1010  Int_t event =0;
1011  Int_t skipped=0 ;
1012  char file[120] ;
1013  char filexs[120] ;
1014 
1015  for (event = 0 ; event < kFile ; event++) {
1016  sprintf(file, "%s/%s%d/%s", kInDir,kPattern,event,datafile.Data()) ;
1017  sprintf(filexs, "%s/%s%d/%s", kInDir,kPattern,event,kXSFileName) ;
1018  TFile * fData = 0 ;
1019  // Check if file exists and add it, if not skip it
1020  if ( fData = TFile::Open(file))
1021  {
1022  if ( fData->Get(kTreeName) )
1023  {
1024  printf("++++ Adding %s\n", file) ;
1025  chain->AddFile(file);
1026 
1027  if(kInputData != "AOD")
1028  {
1029  chainxs->Add(filexs) ;
1030  }
1031  else
1032  {
1033  TFile* fxsec = TFile::Open(filexs);
1034  if(fxsec)
1035  {
1036  TKey* key = (TKey*)fxsec->GetListOfKeys()->At(0);
1037  if(!key)
1038  {
1039  fxsec->Close();
1040  printf("No key!");
1041  continue;
1042  }
1043 
1044  TList *list = dynamic_cast<TList*>(key->ReadObj());
1045  if(!list)
1046  {
1047  fxsec->Close();
1048  printf("No list!");
1049  continue;
1050  }
1051 
1052  Float_t xsection = ((TProfile*)list->FindObject("h1Xsec")) ->GetBinContent(1);
1053  Int_t ntrials = ((TH1F*) list->FindObject("h1Trials"))->GetBinContent(1);
1054  fxsec->Close();
1055 
1056  xsArr->SetAt(xsection,event);
1057  trArr->SetAt(ntrials,event);
1058 
1059  printf("recovered xs %f, ntrials %d, event %d\n",xsection,ntrials, event);
1060  //chainxs->Add(tree);
1061  //fileTMP->Close();
1062  } // fxsec exists
1063  } // xs in AODs
1064 
1065  }
1066  }
1067  else
1068  {
1069  printf("---- Skipping %s\n", file) ;
1070  skipped++ ;
1071  }
1072  }
1073  }
1074  else {
1075  TString input = "AliESDs.root" ;
1076  cout<<">>>>>> No list added, take a single file <<<<<<<<< "<<input<<endl;
1077  chain->AddFile(input);
1078  }
1079 
1080  }// local files analysis
1081 
1082  //------------------------------
1083  // GRID xml files
1084  //------------------------------
1085  else if(mode == mGRID)
1086  {
1087  //Get colection file. It is specified by the environmental
1088  //variable XML
1089 
1090  //Feed Grid with collection file
1091  TGridCollection * collection = (TGridCollection*) TAlienCollection::Open(kXML);
1092  if (! collection) {
1093  AliError(Form("%s not found", kXML)) ;
1094  return kFALSE ;
1095  }
1096 
1097  TGridResult* result = collection->GetGridResult("",0 ,0);
1098 
1099  // Makes the ESD chain
1100  printf("*** Getting the Chain ***\n");
1101  for (Int_t index = 0; index < result->GetEntries(); index++) {
1102  TString alienURL = result->GetKey(index, "turl") ;
1103  cout << "================== " << alienURL << endl ;
1104  chain->Add(alienURL) ;
1105 
1106  if(kInputData != "AOD")
1107  {
1108  alienURL.ReplaceAll("AliESDs.root",kXSFileName);
1109  alienURL.ReplaceAll("AliAOD.root",kXSFileName);
1110  chainxs->Add(alienURL) ;
1111  }
1112  else
1113  {
1114  alienURL.ReplaceAll("AliESDs.root","pyxsec_hists.root");
1115  alienURL.ReplaceAll("AliAOD.root", "pyxsec_hists.root");
1116  TFile* fxsec = TFile::Open(alienURL);
1117  if(fxsec)
1118  {
1119  TKey* key = (TKey*)fxsec->GetListOfKeys()->At(0);
1120  if(!key)
1121  {
1122  fxsec->Close();
1123  printf("No key!");
1124  continue;
1125  }
1126 
1127  TList *list = dynamic_cast<TList*>(key->ReadObj());
1128  if(!list)
1129  {
1130  fxsec->Close();
1131  printf("No list!");
1132  continue;
1133  }
1134 
1135  Float_t xsection = ((TProfile*)list->FindObject("h1Xsec")) ->GetBinContent(1);
1136  Int_t ntrials = ((TH1F*) list->FindObject("h1Trials"))->GetBinContent(1);
1137  fxsec->Close();
1138 
1139  xsArr->SetAt(xsection,event);
1140  trArr->SetAt(ntrials,event);
1141 
1142  printf("recovered xs %f, ntrials %d, event %d\n",xsection,ntrials, event);
1143 
1144  } // fxsec exists
1145  } // xs in AODs
1146  }
1147  }// xml analysis
1148 
1149  //------------------------------
1150  // PROOF
1151  //------------------------------
1152  else if (mode == mPROOF)
1153  {
1154  TFileCollection* ds= gProof->GetDataSet(kDatasetPROOF)->GetStagedSubset();
1155 
1156  gROOT->LoadMacro("/afs/in2p3.fr/group/alice/laf/dataset_management/CreateChainFromDataSet.C");
1157  chain = CreateChainFromDataSet(ds, kTreeName , kDatasetNMaxFiles);
1158  printf("chain has %d entries\n",chain->GetEntries());
1159  }
1160 
1161  gSystem->ChangeDirectory(ocwd.Data());
1162 }
1163 
1164 //______________________________
1168 //______________________________
1169 void CheckEnvironmentVariables()
1170 {
1171  sprintf(kTrigger,"");
1172 
1173  Bool_t bRecalibrate = kFALSE;
1174  Bool_t bBadChannel = kFALSE;
1175 
1176  for (int i=0; i< gApplication->Argc();i++){
1177 
1178 #ifdef VERBOSEARGS
1179 
1180  printf("Arg %d: %s\n",i,gApplication->Argv(i));
1181 
1182 #endif
1183 
1184  TString sRun = "";
1185 
1186  if (!(strcmp(gApplication->Argv(i),"--trigger")))
1187  sprintf(trigger,gApplication->Argv(i+1));
1188 
1189  if (!(strcmp(gApplication->Argv(i),"--recalibrate")))
1190  bRecalibrate = atoi(gApplication->Argv(i+1));
1191 
1192  if (!(strcmp(gApplication->Argv(i),"--badchannel")))
1193  bBadChannel = atoi(gApplication->Argv(i+1));
1194 
1195  if (!(strcmp(gApplication->Argv(i),"--run")))
1196  {
1197  sRun = gApplication->Argv(i+1);
1198  if(sRun.Contains("LHC10")) {
1199  kYear = 2010;
1200  }
1201  else {
1202  if(kRun <=0){
1203  kRun = atoi(gApplication->Argv(i+1));
1204  }
1205  else printf("** Run number already set to %d, do not set to %d\n",kRun,atoi(gApplication->Argv(i+1)));
1206  }//numeric run
1207  }//--run available
1208 
1209  }// args loop
1210 
1211  if(!sRun.Contains("LHC10"))
1212  {
1213  if ( kRun < 140000)
1214  {
1215  kYear = 2010;
1216  if( kRun >= 136851 ) kCollision = "PbPb";
1217  }
1218  else if( kRun < 170600)
1219  {
1220  kYear = 2011;
1221  if( kRun >= 166500 ) kCollision = "PbPb";
1222  }
1223  else if( kRun < 200000 )
1224  {
1225  kYear = 2012;
1226  if( kRun >= 194000 ) kCollision = "pPb";
1227  }
1228  else
1229  {
1230  kYear = 2015;
1231  }
1232  }
1233 
1234  if(kMC) sprintf(kTrigger,"");
1235 
1236  printf("*********************************************\n");
1237  //printf("*** Settings trigger %s, recalibrate %d, remove bad channels %d, year %d, collision %s, run %d ***\n",
1238  // kTrigger,bRecalibrate,bBadChannel, kYear,kCollision.Data(), kRun);
1239  printf("*** Settings year %d, collision %s, run %d ***\n",kYear,kCollision.Data(), kRun);
1240  printf("*********************************************\n");
1241 
1242 }
1243 
1244 //______________________________________________________________________________
1258 //______________________________________________________________________________
1259 Bool_t GetAverageXsection(TTree * tree, Double_t & xs, Float_t & ntr, Int_t & n)
1260 {
1261  Double_t xsection = 0 ;
1262  UInt_t ntrials = 0 ;
1263  Int_t nfiles = 0 ;
1264 
1265  xs = 0;
1266  ntr = 0;
1267  n = 0;
1268  if( kInputData != "AOD" && tree))
1269  {
1270  nfiles = tree->GetEntries() ;
1271 
1272  tree->SetBranchAddress("xsection",&xsection);
1273  tree->SetBranchAddress("ntrials" ,&ntrials );
1274  for(Int_t i = 0; i < nfiles; i++)
1275  {
1276  tree->GetEntry(i);
1277  if(xsection > 0)
1278  {
1279  xs += xsection ;
1280  ntr += ntrials ;
1281  n++;
1282  }
1283  cout << "xsection " <<xsection<<" ntrials "<<ntrials<<endl;
1284  } // loop
1285  }
1286  else if( kInputData == "AOD" && xsArr))
1287  {
1288  nfiles = xsArr->GetSize();
1289 
1290  for(Int_t i = 0; i < nfiles; i++)
1291  {
1292  if(xsArr->GetAt(i) > 0)
1293  {
1294  xs += xsArr->GetAt(i) ;
1295  ntr += trArr->GetAt(i) ;
1296  n++;
1297  }
1298  cout << "xsection " <<xsArr->GetAt(i)<<" ntrials "<<trArr->GetAt(i)<<endl;
1299  } // loop
1300  }
1301  else return kFALSE;
1302 
1303  xs = xs / n;
1304  ntr = ntr / n;
1305  cout << "-----------------------------------------------------------------"<<endl;
1306  cout << "Average of "<< n <<" files: xsection " <<xs<<" ntrials "<<ntr<<endl;
1307  cout << "-----------------------------------------------------------------"<<endl;
1308 
1309  return kTRUE;
1310 }
1311 
1312 
kDatasetNMaxFiles
Int_t kDatasetNMaxFiles
Definition: ana.C:38
alienUserName
TString alienUserName
Definition: ana.C:40
mPROOF
Analyze locally files in your computer.
Definition: ana.C:19
ana
void ana(Int_t mode=mGRID)
Definition: ana.C:86
anaModes
anaModes
Different analysis modes.
Definition: ana.C:16
GetAverageXsection
Bool_t GetAverageXsection(TTree *tree, Double_t &xs, Float_t &ntr, Int_t &n)
Definition: ana.C:1259
LoadLibraries
void LoadLibraries(Int_t mode)
Load analysis libraries.
Definition: ana.C:533
kXML
char * kXML
Definition: ana.C:45
AliAnalysisTaskCounter
Count events with different selection criteria.
Definition: AliAnalysisTaskCounter.h:55
CreateChain
void CreateChain(const anaModes mode, TChain *chain, TChain *chainxs)
Fills chain with data files paths.
Definition: ana.C:938
kPrint
Bool_t kPrint
Global variables to be accessed by the different methods.
Definition: AddTaskCaloTrackCorr.C:10
gSystem
TSystem * gSystem
kPattern
char * kPattern
Global, path to data files.
Definition: ana.C:30
list
TList * list
Definition: DrawAnaCaloTrackQA.C:18
xsArr
TArrayF * xsArr
Name of file with pT-hard cross sections.
Definition: ana.C:55
ccin2p3UserName
TString ccin2p3UserName
Definition: ana.C:39
kPass
TString kPass
Definition: ana.C:68
kCollision
TString kCollision
Definition: ana.C:65
kMC
Bool_t kMC
Definition: ana.C:62
CreateAlienHandler
AliAnalysisAlien * CreateAlienHandler()
Definition: MakeTrend.C:48
kYear
Int_t kYear
ESD, AOD, MC, deltaAOD.
Definition: ana.C:64
trArr
TArrayI * trArr
Definition: ana.C:56
CheckEnvironmentVariables
void CheckEnvironmentVariables()
Definition: ana.C:1169
kInDir
char * kInDir
Definition: ana.C:29
kTreeName
TString kTreeName
Some tasks doesnt need it.
Definition: ana.C:67
CheckInputData
void CheckInputData(const anaModes mode)
Sets input data and tree strings.
Definition: ana.C:696
AddTaskCounter
AliAnalysisTaskCounter * AddTaskCounter(const TString trigger="", Bool_t xsOn=kFALSE)
Definition: AddTaskCounter.C:15
kRun
Int_t kRun
Definition: ana.C:70
outAOD
Bool_t outAOD
Definition: ana.C:66
AddTaskEMCALClusterize
AliAnalysisTaskEMCALClusterize * AddTaskEMCALClusterize(TString &arrayName, const Bool_t bFillAOD=kFALSE, const Int_t bMC=kFALSE, const Bool_t exotic=kTRUE, const TString name="V1Unfold", const TString trigger="", const Bool_t tm=kTRUE, const Int_t minEcell=50, const Int_t minEseed=100, const Int_t maxDeltaT=250, const Int_t timeWindow=1000, const Int_t minEUnf=15, const Int_t minFrac=1, const Bool_t bRecalE=kTRUE, const Bool_t bBad=kTRUE, const Bool_t bRecalT=kTRUE, const Bool_t bNonLine=kFALSE, const Int_t minCen=-1, const Int_t maxCen=-1, const Float_t clusterEnergyCutEvent=-1, const Int_t nRowDiff=1, const Int_t nColDiff=1, const Bool_t skipOrReject=kFALSE)
Definition: AddTaskEMCALClusterize.C:36
mode
Int_t mode
Definition: anaM.C:40
mGRID
Analyze files on GRID with Plugin.
Definition: ana.C:21
mPlugin
Analyze files on GRID with Plugin.
Definition: ana.C:20
SetupPar
void SetupPar(char *pararchivename)
Definition: ana.C:650
kTrigger
char kTrigger[1024]
Definition: ana.C:69
AliAnalysisTaskCaloTrackCorrelation
Main class conecting the CaloTrackCorrelations package and Analysis Frame.
Definition: AliAnalysisTaskCaloTrackCorrelation.h:33
file
TFile * file
Definition: DrawAnaCaloTrackQA.C:19
kXSFileName
const char * kXSFileName
Global name for the xml collection file with data on grid.
Definition: ana.C:52
AddTaskCaloTrackCorr
AliAnalysisTaskCaloTrackCorrelation * AddTaskCaloTrackCorr(const TString data="", const TString calorimeter="EMCAL", const Bool_t simulation=kFALSE, const Bool_t eventsel=kFALSE, const Bool_t exotic=kTRUE, const Bool_t nonlin=kFALSE, TString outputfile="", const Int_t year=2010, const TString col="pp", const TString trigger="MB", const TString clustersArray="V1", const Bool_t mix=kTRUE, const Bool_t recaltm=kTRUE, const Bool_t tm=kTRUE, const Int_t minCen=-1, const Int_t maxCen=-1, const Bool_t qaan=kFALSE, const Bool_t hadronan=kFALSE, const Bool_t calibE=kTRUE, const Bool_t badmap=kTRUE, const Bool_t calibT=kTRUE, const Bool_t tender=kFALSE, const Bool_t outputAOD=kFALSE, const Bool_t printSettings=kFALSE, const Double_t scaleFactor=-1, const Int_t runNumber=-1)
Definition: AddTaskCaloTrackCorr.C:43
kFile
Int_t kFile
Data are in files kInDir/kPattern+i.
Definition: ana.C:31
kInputData
TString kInputData
With real data kMC = kFALSE.
Definition: ana.C:63
AliAnalysisTaskEMCALClusterize
Reclusterize EMCal clusters, put them in a new branch for other following analysis.
Definition: AliAnalysisTaskEMCALClusterize.h:37
kDatasetPROOF
char * kDatasetPROOF
Number of files to analyze in local mode.
Definition: ana.C:37
mLocal
Definition: ana.C:18