PWG2/SPECTRA/macros/runProtonAnalysisQA.C

   1 void runProtonAnalysisQA(const char* esdAnalysisType = "Hybrid",
   2                          const char* pidMode = "Bayesian") {
   3   //Macro to run the proton QA analysis tested for local, proof & GRID.
   4   //Local: Takes four arguments, the analysis mode, the type of the ESD
   5   //       analysis, the PID mode and the path where the tag and ESD or
   6   //       AOD files reside.
   7   //Interactive: Takes four arguments, the analysis mode, the type of the ESD
   8   //             analysis, the PID mode and the name of the collection of tag
   9   //             files.
  10   //Batch: Takes four arguments, the analysis mode, the type of the ESD
  11   //       analysis, the PID mode and the name of the collection file with
  12   //       the event list for each file.
  13   //Proof: Takes five arguments, the analysis level, the analysis mode in
  14   //       case of ESD, the PID mode, the number of events and the dataset
  15   //       name and .
  16   //Analysis mode can be: "MC", "ESD", "AOD"
  17   //ESD analysis type can be one of the three: "TPC", "Hybrid", "Global"
  18   //PID mode can be one of the four: "Bayesian" (standard Bayesian approach)
  19   //   "Ratio" (ratio of measured over expected/theoretical dE/dx a la STAR)
  20   //   "Sigma1" (N-sigma area around the fitted dE/dx vs P band)
  21   //   "Sigma2" (same as previous but taking into account the No of TPC points)
  22   TStopwatch timer;
  23   timer.Start();
  24
  25   //runLocal("ESD",esdAnalysisType,pidMode,"/home/pchrist/ALICE/Baryons/QA/Local");
  26   runProof("ESD",esdAnalysisType,pidMode,100000,"/COMMON/COMMON/LHC09a4_run8100X#esdTree");
  27   //runInteractive("ESD",esdAnalysisType,pidMode,"wn.xml");
  28   //runBatch("ESD",esdAnalysisType,pidMode,"wn.xml");
  29
  30   timer.Stop();
  31   timer.Print();
  32 }
  33
  34 //_________________________________________________//
  35 void runLocal(const char* mode = "ESD",
  36               const char* analysisType = 0x0,
  37               const char* pidMode = 0x0,
  38               const char* path = 0x0) {
  39   TString outputFilename1 = "Protons.QA."; outputFilename1 += analysisType;
  40   outputFilename1 += "."; outputFilename1 += pidMode;
  41   outputFilename1 += ".root"; //main QA file
  42   TString outputFilename2 = "Protons.MC.QA."; outputFilename2 += analysisType;
  43   outputFilename2 += "."; outputFilename2 += pidMode;
  44   outputFilename2 += ".root"; //MC process QA
  45   TString outputFilename3 = "Protons.QA.Histograms.";
  46   outputFilename3 += analysisType;
  47   outputFilename3 += "."; outputFilename2 += pidMode;
  48   outputFilename3 += ".root"; //Accepted cut distributions
  49   TString outputFilename4 = "Protons.Efficiency.";
  50   outputFilename4 += analysisType;
  51   outputFilename4 += "."; outputFilename2 += pidMode;
  52   outputFilename4 += ".root"; //Reco and PID efficiency
  53   TString outputFilename5 = "Vertex.QA.root"; //vertex QA
  54
  55   gSystem->Load("libProofPlayer.so");
  56
  57   //Setup the par files
  58   setupPar("STEERBase");
  59   gSystem->Load("libSTEERBase.so");
  60   setupPar("ESD");
  61   gSystem->Load("libESD.so");
  62   setupPar("AOD");
  63   gSystem->Load("libAOD.so");
  64   setupPar("ANALYSIS");
  65   gSystem->Load("libANALYSIS.so");
  66   setupPar("ANALYSISalice");
  67   gSystem->Load("libANALYSISalice.so");
  68   setupPar("CORRFW");
  69   gSystem->Load("libCORRFW.so");
  70   setupPar("PWG2spectra");
  71   gSystem->Load("libPWG2spectra.so");
  72
  73    //____________________________________________//
  74   AliTagAnalysis *tagAnalysis = new AliTagAnalysis("ESD");
  75   tagAnalysis->ChainLocalTags(path);
  76
  77   AliRunTagCuts *runCuts = new AliRunTagCuts();
  78   AliLHCTagCuts *lhcCuts = new AliLHCTagCuts();
  79   AliDetectorTagCuts *detCuts = new AliDetectorTagCuts();
  80   AliEventTagCuts *evCuts = new AliEventTagCuts();
  81
  82   TChain* chain = 0x0;
  83   chain = tagAnalysis->QueryTags(runCuts,lhcCuts,detCuts,evCuts);
  84   chain->SetBranchStatus("*Calo*",0);
  85
  86   //____________________________________________//
  87   gROOT->LoadMacro("configProtonAnalysis.C");
  88   AliProtonQAAnalysis *analysis = GetProtonQAAnalysisObject(mode,
  89                                                             analysisType,
  90                                                             pidMode);
  91   //____________________________________________//
  92   // Make the analysis manager
  93   AliAnalysisManager *mgr = new AliAnalysisManager("protonAnalysisQAManager");
  94   AliVEventHandler* esdH = new AliESDInputHandler;
  95   mgr->SetInputEventHandler(esdH);
  96   AliMCEventHandler *mc = new AliMCEventHandler();
  97   mgr->SetMCtruthEventHandler(mc);
  98
  99   //____________________________________________//
 100   // 1st Proton task
 101   AliAnalysisTaskProtonsQA *taskProtonsQA = new AliAnalysisTaskProtonsQA("TaskProtonsQA");
 102   taskProtonsQA->SetAnalysisObject(analysis);
 103   mgr->AddTask(taskProtonsQA);
 104
 105   // Create containers for input/output
 106   AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("dataChain",
 107                                                            TChain::Class(),
 108                                                            AliAnalysisManager::kInputContainer);
 109   AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("globalQAList",
 110                                                             TList::Class(),
 111                                                             AliAnalysisManager::kOutputContainer,
 112                                                             outputFilename1.Data());
 113   AliAnalysisDataContainer *coutput2 = mgr->CreateContainer("pdgCodeList",
 114                                                             TList::Class(),
 115                                                             AliAnalysisManager::kOutputContainer,
 116                                                             outputFilename2.Data());
 117   AliAnalysisDataContainer *coutput3 = mgr->CreateContainer("mcProcessList",
 118                                                             TList::Class(),
 119                                                             AliAnalysisManager::kOutputContainer,
 120                                                             outputFilename2.Data());
 121   AliAnalysisDataContainer *coutput4 = mgr->CreateContainer("acceptedCutList",
 122                                                             TList::Class(),
 123                                                             AliAnalysisManager::kOutputContainer,
 124                                                             outputFilename3.Data());
 125   AliAnalysisDataContainer *coutput5 = mgr->CreateContainer("rejectedCutList",
 126                                                             TList::Class(),
 127                                                             AliAnalysisManager::kOutputContainer,
 128                                                             outputFilename3.Data());
 129   AliAnalysisDataContainer *coutput6 = mgr->CreateContainer("acceptedDCAList",
 130                                                             TList::Class(),
 131                                                             AliAnalysisManager::kOutputContainer,
 132                                                             outputFilename3.Data());
 133   AliAnalysisDataContainer *coutput7 = mgr->CreateContainer("efficiencyList",
 134                                                             TList::Class(),
 135                                                             AliAnalysisManager::kOutputContainer,
 136                                                             outputFilename4.Data());
 137   AliAnalysisDataContainer *coutput8 = mgr->CreateContainer("vertexList",
 138                                                             TList::Class(),
 139                                                             AliAnalysisManager::kOutputContainer,
 140                                                             outputFilename5.Data());
 141
 142   //____________________________________________//
 143   mgr->ConnectInput(taskProtonsQA,0,cinput1);
 144   mgr->ConnectOutput(taskProtonsQA,0,coutput1);
 145   mgr->ConnectOutput(taskProtonsQA,1,coutput2);
 146   mgr->ConnectOutput(taskProtonsQA,2,coutput3);
 147   mgr->ConnectOutput(taskProtonsQA,3,coutput4);
 148   mgr->ConnectOutput(taskProtonsQA,4,coutput5);
 149   mgr->ConnectOutput(taskProtonsQA,5,coutput6);
 150   mgr->ConnectOutput(taskProtonsQA,6,coutput7);
 151   mgr->ConnectOutput(taskProtonsQA,7,coutput8);
 152   if (!mgr->InitAnalysis()) return;
 153   mgr->PrintStatus();
 154   mgr->StartAnalysis("local",chain);
 155 }
 156
 157 //_________________________________________________//
 158 void runInteractive(const char* mode = "ESD",
 159                     const char* analysisType = 0x0,
 160                     const char* pidMode = 0x0,
 161                     const char* collectionName = "tag.xml") {
 162   TString outputFilename1 = "Protons.QA."; outputFilename1 += analysisType;
 163   outputFilename1 += "."; outputFilename1 += pidMode;
 164   outputFilename1 += ".root"; //main QA file
 165   TString outputFilename2 = "Protons.MC.QA."; outputFilename2 += analysisType;
 166   outputFilename2 += "."; outputFilename2 += pidMode;
 167   outputFilename2 += ".root"; //MC process QA
 168   TString outputFilename3 = "Protons.QA.Histograms.";
 169   outputFilename3 += analysisType;
 170   outputFilename3 += "."; outputFilename3 += pidMode;
 171   outputFilename3 += ".root"; //Accepted cut distributions
 172   TString outputFilename4 = "Protons.Efficiency.";
 173   outputFilename4 += analysisType;
 174   outputFilename4 += "."; outputFilename4 += pidMode;
 175   outputFilename4 += ".root"; //Reco and PID efficiency
 176   TString outputFilename5 = "Vertex.QA.root"; //vertex QA
 177
 178   TGrid::Connect("alien://");
 179
 180   //Setup the par files
 181   setupPar("STEERBase");
 182   gSystem->Load("libSTEERBase.so");
 183   setupPar("ESD");
 184   gSystem->Load("libESD.so");
 185   setupPar("AOD");
 186   gSystem->Load("libAOD.so");
 187   setupPar("ANALYSIS");
 188   gSystem->Load("libANALYSIS.so");
 189   setupPar("ANALYSISalice");
 190   gSystem->Load("libANALYSISalice.so");
 191   setupPar("CORRFW");
 192   gSystem->Load("libCORRFW.so");
 193   setupPar("PWG2spectra");
 194   gSystem->Load("libPWG2spectra.so");
 195
 196   //____________________________________________//
 197   AliTagAnalysis *tagAnalysis = new AliTagAnalysis("ESD");
 198
 199   AliRunTagCuts *runCuts = new AliRunTagCuts();
 200   AliLHCTagCuts *lhcCuts = new AliLHCTagCuts();
 201   AliDetectorTagCuts *detCuts = new AliDetectorTagCuts();
 202   AliEventTagCuts *evCuts = new AliEventTagCuts();
 203
 204   //grid tags
 205   TAlienCollection* coll = TAlienCollection::Open(collectionName);
 206   TGridResult* TagResult = coll->GetGridResult("",0,0);
 207   tagAnalysis->ChainGridTags(TagResult);
 208   TChain* chain = 0x0;
 209   chain = tagAnalysis->QueryTags(runCuts,lhcCuts,detCuts,evCuts);
 210   chain->SetBranchStatus("*Calo*",0);
 211
 212   //____________________________________________//
 213   gROOT->LoadMacro("configProtonAnalysis.C");
 214   AliProtonQAAnalysis *analysis = GetProtonQAAnalysisObject(mode,
 215                                                             analysisType,
 216                                                             pidMode);
 217   //____________________________________________//
 218   // Make the analysis manager
 219   AliAnalysisManager *mgr = new AliAnalysisManager("protonAnalysisQAManager");
 220   AliVEventHandler* esdH = new AliESDInputHandler;
 221   mgr->SetInputEventHandler(esdH);
 222   AliMCEventHandler *mc = new AliMCEventHandler();
 223   mgr->SetMCtruthEventHandler(mc);
 224
 225   //____________________________________________//
 226   // 1st Proton task
 227   AliAnalysisTaskProtonsQA *taskProtonsQA = new AliAnalysisTaskProtonsQA("TaskProtonsQA");
 228   taskProtonsQA->SetAnalysisObject(analysis);
 229   mgr->AddTask(taskProtonsQA);
 230
 231   // Create containers for input/output
 232   AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("dataChain",
 233                                                            TChain::Class(),
 234                                                            AliAnalysisManager::kInputContainer);
 235   AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("globalQAList",
 236                                                             TList::Class(),
 237                                                             AliAnalysisManager::kOutputContainer,
 238                                                             outputFilename1.Data());
 239   AliAnalysisDataContainer *coutput2 = mgr->CreateContainer("pdgCodeList",
 240                                                             TList::Class(),
 241                                                             AliAnalysisManager::kOutputContainer,
 242                                                             outputFilename2.Data());
 243   AliAnalysisDataContainer *coutput3 = mgr->CreateContainer("mcProcessList",
 244                                                             TList::Class(),
 245                                                             AliAnalysisManager::kOutputContainer,
 246                                                             outputFilename2.Data());
 247   AliAnalysisDataContainer *coutput4 = mgr->CreateContainer("acceptedCutList",
 248                                                             TList::Class(),
 249                                                             AliAnalysisManager::kOutputContainer,
 250                                                             outputFilename3.Data());
 251   AliAnalysisDataContainer *coutput5 = mgr->CreateContainer("rejectedCutList",
 252                                                             TList::Class(),
 253                                                             AliAnalysisManager::kOutputContainer,
 254                                                             outputFilename3.Data());
 255   AliAnalysisDataContainer *coutput6 = mgr->CreateContainer("acceptedDCAList",
 256                                                             TList::Class(),
 257                                                             AliAnalysisManager::kOutputContainer,
 258                                                             outputFilename3.Data());
 259   AliAnalysisDataContainer *coutput7 = mgr->CreateContainer("efficiencyList",
 260                                                             TList::Class(),
 261                                                             AliAnalysisManager::kOutputContainer,
 262                                                             outputFilename4.Data());
 263   AliAnalysisDataContainer *coutput8 = mgr->CreateContainer("vertexList",
 264                                                             TList::Class(),
 265                                                             AliAnalysisManager::kOutputContainer,
 266                                                             outputFilename5.Data());
 267
 268   //____________________________________________//
 269   mgr->ConnectInput(taskProtonsQA,0,cinput1);
 270   mgr->ConnectOutput(taskProtonsQA,0,coutput1);
 271   mgr->ConnectOutput(taskProtonsQA,1,coutput2);
 272   mgr->ConnectOutput(taskProtonsQA,2,coutput3);
 273   mgr->ConnectOutput(taskProtonsQA,3,coutput4);
 274   mgr->ConnectOutput(taskProtonsQA,4,coutput5);
 275   mgr->ConnectOutput(taskProtonsQA,5,coutput6);
 276   mgr->ConnectOutput(taskProtonsQA,6,coutput7);
 277   mgr->ConnectOutput(taskProtonsQA,7,coutput8);
 278   if (!mgr->InitAnalysis()) return;
 279   mgr->PrintStatus();
 280   mgr->StartAnalysis("local",chain);
 281 }
 282
 283 //_________________________________________________//
 284 void runBatch(const char* mode = "ESD",
 285               const char* analysisType = 0x0,
 286               const char* pidMode = 0x0,
 287               const char *collectionfile = "wn.xml") {
 288   TString outputFilename1 = "Protons.QA."; outputFilename1 += analysisType;
 289   outputFilename1 += "."; outputFilename1 += pidMode;
 290   outputFilename1 += ".root"; //main QA file
 291   TString outputFilename2 = "Protons.MC.QA."; outputFilename2 += analysisType;
 292   outputFilename2 += "."; outputFilename2 += pidMode;
 293   outputFilename2 += ".root"; //MC process QA
 294   TString outputFilename3 = "Protons.QA.Histograms.";
 295   outputFilename3 += analysisType;
 296   outputFilename3 += "."; outputFilename3 += pidMode;
 297   outputFilename3 += ".root"; //Accepted cut distributions
 298   TString outputFilename4 = "Protons.Efficiency.";
 299   outputFilename4 += analysisType;
 300   outputFilename4 += "."; outputFilename4 += pidMode;
 301   outputFilename4 += ".root"; //Reco and PID efficiency
 302   TString outputFilename5 = "Vertex.QA.root"; //vertex QA
 303
 304   TGrid::Connect("alien://");
 305   gSystem->Load("libProofPlayer.so");
 306
 307   //Setup the par files
 308   setupPar("STEERBase");
 309   gSystem->Load("libSTEERBase.so");
 310   setupPar("ESD");
 311   gSystem->Load("libESD.so");
 312   setupPar("AOD");
 313   gSystem->Load("libAOD.so");
 314   setupPar("ANALYSIS");
 315   gSystem->Load("libANALYSIS.so");
 316   setupPar("ANALYSISalice");
 317   gSystem->Load("libANALYSISalice.so");
 318   setupPar("CORRFW");
 319   gSystem->Load("libCORRFW.so");
 320   setupPar("PWG2spectra");
 321   gSystem->Load("libPWG2spectra.so");
 322
 323   //____________________________________________//
 324   //Usage of event tags
 325   AliTagAnalysis *tagAnalysis = new AliTagAnalysis();
 326   TChain *chain = 0x0;
 327   chain = tagAnalysis->GetChainFromCollection(collectionfile,"esdTree");
 328   chain->SetBranchStatus("*Calo*",0);
 329
 330   //____________________________________________//
 331   gROOT->LoadMacro("configProtonAnalysis.C");
 332   AliProtonQAAnalysis *analysis = GetProtonQAAnalysisObject(mode,
 333                                                             analysisType,
 334                                                             pidMode);
 335   //____________________________________________//
 336   // Make the analysis manager
 337   AliAnalysisManager *mgr = new AliAnalysisManager("protonAnalysisQAManager");
 338   AliVEventHandler* esdH = new AliESDInputHandler;
 339   mgr->SetInputEventHandler(esdH);
 340   AliMCEventHandler *mc = new AliMCEventHandler();
 341   mgr->SetMCtruthEventHandler(mc);
 342
 343   //____________________________________________//
 344   // 1st Proton task
 345   AliAnalysisTaskProtonsQA *taskProtonsQA = new AliAnalysisTaskProtonsQA("TaskProtonsQA");
 346   taskProtonsQA->SetAnalysisObject(analysis);
 347   mgr->AddTask(taskProtonsQA);
 348
 349   // Create containers for input/output
 350   AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("dataChain",
 351                                                            TChain::Class(),
 352                                                            AliAnalysisManager::kInputContainer);
 353   AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("globalQAList",
 354                                                             TList::Class(),
 355                                                             AliAnalysisManager::kOutputContainer,
 356                                                             outputFilename1.Data());
 357   AliAnalysisDataContainer *coutput2 = mgr->CreateContainer("pdgCodeList",
 358                                                             TList::Class(),
 359                                                             AliAnalysisManager::kOutputContainer,
 360                                                             outputFilename2.Data());
 361   AliAnalysisDataContainer *coutput3 = mgr->CreateContainer("mcProcessList",
 362                                                             TList::Class(),
 363                                                             AliAnalysisManager::kOutputContainer,
 364                                                             outputFilename2.Data());
 365   AliAnalysisDataContainer *coutput4 = mgr->CreateContainer("acceptedCutList",
 366                                                             TList::Class(),
 367                                                             AliAnalysisManager::kOutputContainer,
 368                                                             outputFilename3.Data());
 369   AliAnalysisDataContainer *coutput5 = mgr->CreateContainer("rejectedCutList",
 370                                                             TList::Class(),
 371                                                             AliAnalysisManager::kOutputContainer,
 372                                                             outputFilename3.Data());
 373   AliAnalysisDataContainer *coutput6 = mgr->CreateContainer("acceptedDCAList",
 374                                                             TList::Class(),
 375                                                             AliAnalysisManager::kOutputContainer,
 376                                                             outputFilename3.Data());
 377   AliAnalysisDataContainer *coutput7 = mgr->CreateContainer("efficiencyList",
 378                                                             TList::Class(),
 379                                                             AliAnalysisManager::kOutputContainer,
 380                                                             outputFilename4.Data());
 381   AliAnalysisDataContainer *coutput8 = mgr->CreateContainer("vertexList",
 382                                                             TList::Class(),
 383                                                             AliAnalysisManager::kOutputContainer,
 384                                                             outputFilename5.Data());
 385
 386   //____________________________________________//
 387   mgr->ConnectInput(taskProtonsQA,0,cinput1);
 388   mgr->ConnectOutput(taskProtonsQA,0,coutput1);
 389   mgr->ConnectOutput(taskProtonsQA,1,coutput2);
 390   mgr->ConnectOutput(taskProtonsQA,2,coutput3);
 391   mgr->ConnectOutput(taskProtonsQA,3,coutput4);
 392   mgr->ConnectOutput(taskProtonsQA,4,coutput5);
 393   mgr->ConnectOutput(taskProtonsQA,5,coutput6);
 394   mgr->ConnectOutput(taskProtonsQA,6,coutput7);
 395   mgr->ConnectOutput(taskProtonsQA,7,coutput8);
 396   if (!mgr->InitAnalysis()) return;
 397   mgr->PrintStatus();
 398   mgr->StartAnalysis("local",chain);
 399 }
 400
 401 //_________________________________________________//
 402 void runProof(const char* mode = "ESD",
 403               const char* analysisType = 0x0,
 404               const char* pidMode = 0x0,
 405               Int_t stats = 0,
 406               const char* dataset = 0x0) {
 407   TString outputFilename1 = "Protons.QA."; outputFilename1 += analysisType;
 408   outputFilename1 += "."; outputFilename1 += pidMode;
 409   outputFilename1 += ".root"; //main QA file
 410   TString outputFilename2 = "Protons.MC.QA."; outputFilename2 += analysisType;
 411   outputFilename2 += "."; outputFilename2 += pidMode;
 412   outputFilename2 += ".root"; //MC process QA
 413   TString outputFilename3 = "Protons.QA.Histograms.";
 414   outputFilename3 += analysisType;
 415   outputFilename3 += "."; outputFilename3 += pidMode;
 416   outputFilename3 += ".root"; //Accepted cut distributions
 417   TString outputFilename4 = "Protons.Efficiency.";
 418   outputFilename4 += analysisType;
 419   outputFilename4 += "."; outputFilename4 += pidMode;
 420   outputFilename4 += ".root"; //Reco and PID efficiency
 421   TString outputFilename5 = "Vertex.QA.root"; //vertex QA
 422
 423   printf("****** Connect to PROOF *******\n");
 424   TProof::Open("alicecaf.cern.ch");
 425   gProof->SetParallel();
 426
 427   // Enable the Analysis Package
 428   gProof->UploadPackage("STEERBase.par");
 429   gProof->EnablePackage("STEERBase");
 430   gProof->UploadPackage("ESD.par");
 431   gProof->EnablePackage("ESD");
 432   gProof->UploadPackage("AOD.par");
 433   gProof->EnablePackage("AOD");
 434   gProof->UploadPackage("ANALYSIS.par");
 435   gProof->EnablePackage("ANALYSIS");
 436   gProof->UploadPackage("ANALYSISalice.par");
 437   gProof->EnablePackage("ANALYSISalice");
 438   gProof->UploadPackage("CORRFW.par");
 439   gProof->EnablePackage("CORRFW");
 440   gProof->UploadPackage("PWG2spectra.par");
 441   gProof->EnablePackage("PWG2spectra");
 442
 443   //____________________________________________//
 444   //gProof->Load("configProtonAnalysis.C");
 445   gROOT->LoadMacro("configProtonAnalysis.C");
 446   AliProtonQAAnalysis *analysis = GetProtonQAAnalysisObject(mode,
 447                                                             analysisType,
 448                                                             pidMode);
 449   //____________________________________________//
 450   // Make the analysis manager
 451   AliAnalysisManager *mgr = new AliAnalysisManager("protonAnalysisQAManager");
 452   AliVEventHandler* esdH = new AliESDInputHandler;
 453   mgr->SetInputEventHandler(esdH);
 454   AliMCEventHandler *mc = new AliMCEventHandler();
 455   mgr->SetMCtruthEventHandler(mc);
 456
 457   //____________________________________________//
 458   // 1st Proton task
 459   AliAnalysisTaskProtonsQA *taskProtonsQA = new AliAnalysisTaskProtonsQA("TaskProtonsQA");
 460   taskProtonsQA->SetAnalysisObject(analysis);
 461   mgr->AddTask(taskProtonsQA);
 462
 463   // Create containers for input/output
 464   AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("dataChain",
 465                                                            TChain::Class(),
 466                                                            AliAnalysisManager::kInputContainer);
 467   AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("globalQAList",
 468                                                             TList::Class(),
 469                                                             AliAnalysisManager::kOutputContainer,
 470                                                             outputFilename1.Data());
 471   AliAnalysisDataContainer *coutput2 = mgr->CreateContainer("pdgCodeList",
 472                                                             TList::Class(),
 473                                                             AliAnalysisManager::kOutputContainer,
 474                                                             outputFilename2.Data());
 475   AliAnalysisDataContainer *coutput3 = mgr->CreateContainer("mcProcessList",
 476                                                             TList::Class(),
 477                                                             AliAnalysisManager::kOutputContainer,
 478                                                             outputFilename2.Data());
 479   AliAnalysisDataContainer *coutput4 = mgr->CreateContainer("acceptedCutList",
 480                                                             TList::Class(),
 481                                                             AliAnalysisManager::kOutputContainer,
 482                                                             outputFilename3.Data());
 483   AliAnalysisDataContainer *coutput5 = mgr->CreateContainer("rejectedCutList",
 484                                                             TList::Class(),
 485                                                             AliAnalysisManager::kOutputContainer,
 486                                                             outputFilename3.Data());
 487   AliAnalysisDataContainer *coutput6 = mgr->CreateContainer("acceptedDCAList",
 488                                                             TList::Class(),
 489                                                             AliAnalysisManager::kOutputContainer,
 490                                                             outputFilename3.Data());
 491   AliAnalysisDataContainer *coutput7 = mgr->CreateContainer("efficiencyList",
 492                                                             TList::Class(),
 493                                                             AliAnalysisManager::kOutputContainer,
 494                                                             outputFilename4.Data());
 495   AliAnalysisDataContainer *coutput8 = mgr->CreateContainer("vertexList",
 496                                                             TList::Class(),
 497                                                             AliAnalysisManager::kOutputContainer,
 498                                                             outputFilename5.Data());
 499
 500   //____________________________________________//
 501   mgr->ConnectInput(taskProtonsQA,0,cinput1);
 502   mgr->ConnectOutput(taskProtonsQA,0,coutput1);
 503   mgr->ConnectOutput(taskProtonsQA,1,coutput2);
 504   mgr->ConnectOutput(taskProtonsQA,2,coutput3);
 505   mgr->ConnectOutput(taskProtonsQA,3,coutput4);
 506   mgr->ConnectOutput(taskProtonsQA,4,coutput5);
 507   mgr->ConnectOutput(taskProtonsQA,5,coutput6);
 508   mgr->ConnectOutput(taskProtonsQA,6,coutput7);
 509   mgr->ConnectOutput(taskProtonsQA,7,coutput8);
 510   if (!mgr->InitAnalysis()) return;
 511   mgr->PrintStatus();
 512
 513   if(dataset)
 514     mgr->StartAnalysis("proof",dataset,stats);
 515   else {
 516     // You should get this macro and the txt file from:
 517     // http://aliceinfo.cern.ch/Offline/Analysis/CAF/
 518     gROOT->LoadMacro("CreateESDChain.C");
 519     TChain* chain = 0x0;
 520     chain = CreateESDChain("ESD82XX_30K.txt",stats);
 521     chain->SetBranchStatus("*Calo*",0);
 522
 523     mgr->StartAnalysis("proof",chain);
 524     //mgr->StartAnalysis("local",chain);
 525   }
 526 }
 527
 528 //_________________________________________________//
 529 Int_t setupPar(const char* pararchivename) {
 530   ///////////////////
 531   // Setup PAR File//
 532   ///////////////////
 533   if (pararchivename) {
 534     char processline[1024];
 535     sprintf(processline,".! tar xvzf %s.par",pararchivename);
 536     gROOT->ProcessLine(processline);
 537     const char* ocwd = gSystem->WorkingDirectory();
 538     gSystem->ChangeDirectory(pararchivename);
 539
 540     // check for BUILD.sh and execute
 541     if (!gSystem->AccessPathName("PROOF-INF/BUILD.sh")) {
 542       printf("*******************************\n");
 543       printf("*** Building PAR archive    ***\n");
 544       printf("*******************************\n");
 545
 546       if (gSystem->Exec("PROOF-INF/BUILD.sh")) {
 547         Error("runAnalysis","Cannot Build the PAR Archive! - Abort!");
 548         return -1;
 549       }
 550     }
 551     // check for SETUP.C and execute
 552     if (!gSystem->AccessPathName("PROOF-INF/SETUP.C")) {
 553       printf("*******************************\n");
 554       printf("*** Setup PAR archive       ***\n");
 555       printf("*******************************\n");
 556       gROOT->Macro("PROOF-INF/SETUP.C");
 557     }
 558
 559     gSystem->ChangeDirectory("../");
 560   }
 561   return 1;
 562 }