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