PWG2/SPECTRA/macros/runProtonAnalysisQA.C

   1 void runProtonAnalysisQA(const char* esdAnalysisType = "Hybrid",
   2                          const char* pidMode = "Sigma1") {
   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/LHC09d10_run104792-3#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 += "."; outputFilename3 += pidMode;
  48   outputFilename3 += ".root"; //Accepted cut distributions
  49   TString outputFilename4 = "Protons.Efficiency.";
  50   outputFilename4 += analysisType;
  51   outputFilename4 += "."; outputFilename4 += 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 *cinput1  = mgr->GetCommonInputContainer();
 110   AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("globalQAList",
 111                                                             TList::Class(),
 112                                                             AliAnalysisManager::kOutputContainer,
 113                                                             outputFilename1.Data());
 114   AliAnalysisDataContainer *coutput2 = mgr->CreateContainer("pdgCodeList",
 115                                                             TList::Class(),
 116                                                             AliAnalysisManager::kOutputContainer,
 117                                                             outputFilename2.Data());
 118   AliAnalysisDataContainer *coutput3 = mgr->CreateContainer("mcProcessList",
 119                                                             TList::Class(),
 120                                                             AliAnalysisManager::kOutputContainer,
 121                                                             outputFilename2.Data());
 122   AliAnalysisDataContainer *coutput4 = mgr->CreateContainer("acceptedCutList",
 123                                                             TList::Class(),
 124                                                             AliAnalysisManager::kOutputContainer,
 125                                                             outputFilename3.Data());
 126   AliAnalysisDataContainer *coutput5 = mgr->CreateContainer("rejectedCutList",
 127                                                             TList::Class(),
 128                                                             AliAnalysisManager::kOutputContainer,
 129                                                             outputFilename3.Data());
 130   AliAnalysisDataContainer *coutput6 = mgr->CreateContainer("acceptedDCAList",
 131                                                             TList::Class(),
 132                                                             AliAnalysisManager::kOutputContainer,
 133                                                             outputFilename3.Data());
 134   AliAnalysisDataContainer *coutput7 = mgr->CreateContainer("efficiencyList",
 135                                                             TList::Class(),
 136                                                             AliAnalysisManager::kOutputContainer,
 137                                                             outputFilename4.Data());
 138   AliAnalysisDataContainer *coutput8 = mgr->CreateContainer("vertexList",
 139                                                             TList::Class(),
 140                                                             AliAnalysisManager::kOutputContainer,
 141                                                             outputFilename5.Data());
 142   AliAnalysisDataContainer *coutput9 = mgr->CreateContainer("cutEfficiencyList",
 143                                                             TList::Class(),
 144                                                             AliAnalysisManager::kOutputContainer,
 145                                                             outputFilename4.Data());
 146
 147   //____________________________________________//
 148   mgr->ConnectInput(taskProtonsQA,0,cinput1);
 149   mgr->ConnectOutput(taskProtonsQA,0,coutput1);
 150   mgr->ConnectOutput(taskProtonsQA,1,coutput2);
 151   mgr->ConnectOutput(taskProtonsQA,2,coutput3);
 152   mgr->ConnectOutput(taskProtonsQA,3,coutput4);
 153   mgr->ConnectOutput(taskProtonsQA,4,coutput5);
 154   mgr->ConnectOutput(taskProtonsQA,5,coutput6);
 155   mgr->ConnectOutput(taskProtonsQA,6,coutput7);
 156   mgr->ConnectOutput(taskProtonsQA,7,coutput8);
 157   mgr->ConnectOutput(taskProtonsQA,8,coutput9);
 158
 159   if (!mgr->InitAnalysis()) return;
 160   mgr->PrintStatus();
 161   mgr->StartAnalysis("local",chain);
 162 }
 163
 164 //_________________________________________________//
 165 void runInteractive(const char* mode = "ESD",
 166                     const char* analysisType = 0x0,
 167                     const char* pidMode = 0x0,
 168                     const char* collectionName = "tag.xml") {
 169   TString outputFilename1 = "Protons.QA."; outputFilename1 += analysisType;
 170   outputFilename1 += "."; outputFilename1 += pidMode;
 171   outputFilename1 += ".root"; //main QA file
 172   TString outputFilename2 = "Protons.MC.QA."; outputFilename2 += analysisType;
 173   outputFilename2 += "."; outputFilename2 += pidMode;
 174   outputFilename2 += ".root"; //MC process QA
 175   TString outputFilename3 = "Protons.QA.Histograms.";
 176   outputFilename3 += analysisType;
 177   outputFilename3 += "."; outputFilename3 += pidMode;
 178   outputFilename3 += ".root"; //Accepted cut distributions
 179   TString outputFilename4 = "Protons.Efficiency.";
 180   outputFilename4 += analysisType;
 181   outputFilename4 += "."; outputFilename4 += pidMode;
 182   outputFilename4 += ".root"; //Reco and PID efficiency
 183   TString outputFilename5 = "Vertex.QA.root"; //vertex QA
 184
 185   TGrid::Connect("alien://");
 186
 187   //Setup the par files
 188   setupPar("STEERBase");
 189   gSystem->Load("libSTEERBase.so");
 190   setupPar("ESD");
 191   gSystem->Load("libESD.so");
 192   setupPar("AOD");
 193   gSystem->Load("libAOD.so");
 194   setupPar("ANALYSIS");
 195   gSystem->Load("libANALYSIS.so");
 196   setupPar("ANALYSISalice");
 197   gSystem->Load("libANALYSISalice.so");
 198   setupPar("CORRFW");
 199   gSystem->Load("libCORRFW.so");
 200   setupPar("PWG2spectra");
 201   gSystem->Load("libPWG2spectra.so");
 202
 203   //____________________________________________//
 204   AliTagAnalysis *tagAnalysis = new AliTagAnalysis("ESD");
 205
 206   AliRunTagCuts *runCuts = new AliRunTagCuts();
 207   AliLHCTagCuts *lhcCuts = new AliLHCTagCuts();
 208   AliDetectorTagCuts *detCuts = new AliDetectorTagCuts();
 209   AliEventTagCuts *evCuts = new AliEventTagCuts();
 210
 211   //grid tags
 212   TAlienCollection* coll = TAlienCollection::Open(collectionName);
 213   TGridResult* TagResult = coll->GetGridResult("",0,0);
 214   tagAnalysis->ChainGridTags(TagResult);
 215   TChain* chain = 0x0;
 216   chain = tagAnalysis->QueryTags(runCuts,lhcCuts,detCuts,evCuts);
 217   chain->SetBranchStatus("*Calo*",0);
 218
 219   //____________________________________________//
 220   gROOT->LoadMacro("configProtonAnalysis.C");
 221   AliProtonQAAnalysis *analysis = GetProtonQAAnalysisObject(mode,
 222                                                             analysisType,
 223                                                             pidMode);
 224   //____________________________________________//
 225   // Make the analysis manager
 226   AliAnalysisManager *mgr = new AliAnalysisManager("protonAnalysisQAManager");
 227   AliVEventHandler* esdH = new AliESDInputHandler;
 228   mgr->SetInputEventHandler(esdH);
 229   AliMCEventHandler *mc = new AliMCEventHandler();
 230   mgr->SetMCtruthEventHandler(mc);
 231
 232   //____________________________________________//
 233   // 1st Proton task
 234   AliAnalysisTaskProtonsQA *taskProtonsQA = new AliAnalysisTaskProtonsQA("TaskProtonsQA");
 235   taskProtonsQA->SetAnalysisObject(analysis);
 236   mgr->AddTask(taskProtonsQA);
 237
 238   // Create containers for input/output
 239   /*AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("dataChain",
 240                                                            TChain::Class(),
 241                                                            AliAnalysisManager::kInputContainer);*/
 242   AliAnalysisDataContainer *cinput1  = mgr->GetCommonInputContainer();
 243   AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("globalQAList",
 244                                                             TList::Class(),
 245                                                             AliAnalysisManager::kOutputContainer,
 246                                                             outputFilename1.Data());
 247   AliAnalysisDataContainer *coutput2 = mgr->CreateContainer("pdgCodeList",
 248                                                             TList::Class(),
 249                                                             AliAnalysisManager::kOutputContainer,
 250                                                             outputFilename2.Data());
 251   AliAnalysisDataContainer *coutput3 = mgr->CreateContainer("mcProcessList",
 252                                                             TList::Class(),
 253                                                             AliAnalysisManager::kOutputContainer,
 254                                                             outputFilename2.Data());
 255   AliAnalysisDataContainer *coutput4 = mgr->CreateContainer("acceptedCutList",
 256                                                             TList::Class(),
 257                                                             AliAnalysisManager::kOutputContainer,
 258                                                             outputFilename3.Data());
 259   AliAnalysisDataContainer *coutput5 = mgr->CreateContainer("rejectedCutList",
 260                                                             TList::Class(),
 261                                                             AliAnalysisManager::kOutputContainer,
 262                                                             outputFilename3.Data());
 263   AliAnalysisDataContainer *coutput6 = mgr->CreateContainer("acceptedDCAList",
 264                                                             TList::Class(),
 265                                                             AliAnalysisManager::kOutputContainer,
 266                                                             outputFilename3.Data());
 267   AliAnalysisDataContainer *coutput7 = mgr->CreateContainer("efficiencyList",
 268                                                             TList::Class(),
 269                                                             AliAnalysisManager::kOutputContainer,
 270                                                             outputFilename4.Data());
 271   AliAnalysisDataContainer *coutput8 = mgr->CreateContainer("vertexList",
 272                                                             TList::Class(),
 273                                                             AliAnalysisManager::kOutputContainer,
 274                                                             outputFilename5.Data());
 275   AliAnalysisDataContainer *coutput9 = mgr->CreateContainer("cutEfficiencyList",
 276                                                             TList::Class(),
 277                                                             AliAnalysisManager::kOutputContainer,
 278                                                             outputFilename4.Data());
 279
 280   //____________________________________________//
 281   mgr->ConnectInput(taskProtonsQA,0,cinput1);
 282   mgr->ConnectOutput(taskProtonsQA,0,coutput1);
 283   mgr->ConnectOutput(taskProtonsQA,1,coutput2);
 284   mgr->ConnectOutput(taskProtonsQA,2,coutput3);
 285   mgr->ConnectOutput(taskProtonsQA,3,coutput4);
 286   mgr->ConnectOutput(taskProtonsQA,4,coutput5);
 287   mgr->ConnectOutput(taskProtonsQA,5,coutput6);
 288   mgr->ConnectOutput(taskProtonsQA,6,coutput7);
 289   mgr->ConnectOutput(taskProtonsQA,7,coutput8);
 290   mgr->ConnectOutput(taskProtonsQA,8,coutput9);
 291
 292   if (!mgr->InitAnalysis()) return;
 293   mgr->PrintStatus();
 294   mgr->StartAnalysis("local",chain);
 295 }
 296
 297 //_________________________________________________//
 298 void runBatch(const char* mode = "ESD",
 299               const char* analysisType = 0x0,
 300               const char* pidMode = 0x0,
 301               const char *collectionfile = "wn.xml") {
 302   TString outputFilename1 = "Protons.QA."; outputFilename1 += analysisType;
 303   outputFilename1 += "."; outputFilename1 += pidMode;
 304   outputFilename1 += ".root"; //main QA file
 305   TString outputFilename2 = "Protons.MC.QA."; outputFilename2 += analysisType;
 306   outputFilename2 += "."; outputFilename2 += pidMode;
 307   outputFilename2 += ".root"; //MC process QA
 308   TString outputFilename3 = "Protons.QA.Histograms.";
 309   outputFilename3 += analysisType;
 310   outputFilename3 += "."; outputFilename3 += pidMode;
 311   outputFilename3 += ".root"; //Accepted cut distributions
 312   TString outputFilename4 = "Protons.Efficiency.";
 313   outputFilename4 += analysisType;
 314   outputFilename4 += "."; outputFilename4 += pidMode;
 315   outputFilename4 += ".root"; //Reco and PID efficiency
 316   TString outputFilename5 = "Vertex.QA.root"; //vertex QA
 317
 318   TGrid::Connect("alien://");
 319   gSystem->Load("libProofPlayer.so");
 320
 321   //Setup the par files
 322   setupPar("STEERBase");
 323   gSystem->Load("libSTEERBase.so");
 324   setupPar("ESD");
 325   gSystem->Load("libESD.so");
 326   setupPar("AOD");
 327   gSystem->Load("libAOD.so");
 328   setupPar("ANALYSIS");
 329   gSystem->Load("libANALYSIS.so");
 330   setupPar("ANALYSISalice");
 331   gSystem->Load("libANALYSISalice.so");
 332   setupPar("CORRFW");
 333   gSystem->Load("libCORRFW.so");
 334   setupPar("PWG2spectra");
 335   gSystem->Load("libPWG2spectra.so");
 336
 337   //____________________________________________//
 338   //Usage of event tags
 339   AliTagAnalysis *tagAnalysis = new AliTagAnalysis();
 340   TChain *chain = 0x0;
 341   chain = tagAnalysis->GetChainFromCollection(collectionfile,"esdTree");
 342   chain->SetBranchStatus("*Calo*",0);
 343
 344   //____________________________________________//
 345   gROOT->LoadMacro("configProtonAnalysis.C");
 346   AliProtonQAAnalysis *analysis = GetProtonQAAnalysisObject(mode,
 347                                                             analysisType,
 348                                                             pidMode);
 349   //____________________________________________//
 350   // Make the analysis manager
 351   AliAnalysisManager *mgr = new AliAnalysisManager("protonAnalysisQAManager");
 352   AliVEventHandler* esdH = new AliESDInputHandler;
 353   mgr->SetInputEventHandler(esdH);
 354   AliMCEventHandler *mc = new AliMCEventHandler();
 355   mgr->SetMCtruthEventHandler(mc);
 356
 357   //____________________________________________//
 358   // 1st Proton task
 359   AliAnalysisTaskProtonsQA *taskProtonsQA = new AliAnalysisTaskProtonsQA("TaskProtonsQA");
 360   taskProtonsQA->SetAnalysisObject(analysis);
 361   mgr->AddTask(taskProtonsQA);
 362
 363   // Create containers for input/output
 364   /*AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("dataChain",
 365                                                            TChain::Class(),
 366                                                            AliAnalysisManager::kInputContainer);*/
 367   AliAnalysisDataContainer *cinput1  = mgr->GetCommonInputContainer();
 368   AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("globalQAList",
 369                                                             TList::Class(),
 370                                                             AliAnalysisManager::kOutputContainer,
 371                                                             outputFilename1.Data());
 372   AliAnalysisDataContainer *coutput2 = mgr->CreateContainer("pdgCodeList",
 373                                                             TList::Class(),
 374                                                             AliAnalysisManager::kOutputContainer,
 375                                                             outputFilename2.Data());
 376   AliAnalysisDataContainer *coutput3 = mgr->CreateContainer("mcProcessList",
 377                                                             TList::Class(),
 378                                                             AliAnalysisManager::kOutputContainer,
 379                                                             outputFilename2.Data());
 380   AliAnalysisDataContainer *coutput4 = mgr->CreateContainer("acceptedCutList",
 381                                                             TList::Class(),
 382                                                             AliAnalysisManager::kOutputContainer,
 383                                                             outputFilename3.Data());
 384   AliAnalysisDataContainer *coutput5 = mgr->CreateContainer("rejectedCutList",
 385                                                             TList::Class(),
 386                                                             AliAnalysisManager::kOutputContainer,
 387                                                             outputFilename3.Data());
 388   AliAnalysisDataContainer *coutput6 = mgr->CreateContainer("acceptedDCAList",
 389                                                             TList::Class(),
 390                                                             AliAnalysisManager::kOutputContainer,
 391                                                             outputFilename3.Data());
 392   AliAnalysisDataContainer *coutput7 = mgr->CreateContainer("efficiencyList",
 393                                                             TList::Class(),
 394                                                             AliAnalysisManager::kOutputContainer,
 395                                                             outputFilename4.Data());
 396   AliAnalysisDataContainer *coutput8 = mgr->CreateContainer("vertexList",
 397                                                             TList::Class(),
 398                                                             AliAnalysisManager::kOutputContainer,
 399                                                             outputFilename5.Data());
 400   AliAnalysisDataContainer *coutput9 = mgr->CreateContainer("cutEfficiencyList",
 401                                                             TList::Class(),
 402                                                             AliAnalysisManager::kOutputContainer,
 403                                                             outputFilename4.Data());
 404
 405   //____________________________________________//
 406   mgr->ConnectInput(taskProtonsQA,0,cinput1);
 407   mgr->ConnectOutput(taskProtonsQA,0,coutput1);
 408   mgr->ConnectOutput(taskProtonsQA,1,coutput2);
 409   mgr->ConnectOutput(taskProtonsQA,2,coutput3);
 410   mgr->ConnectOutput(taskProtonsQA,3,coutput4);
 411   mgr->ConnectOutput(taskProtonsQA,4,coutput5);
 412   mgr->ConnectOutput(taskProtonsQA,5,coutput6);
 413   mgr->ConnectOutput(taskProtonsQA,6,coutput7);
 414   mgr->ConnectOutput(taskProtonsQA,7,coutput8);
 415   mgr->ConnectOutput(taskProtonsQA,8,coutput9);
 416
 417   if (!mgr->InitAnalysis()) return;
 418   mgr->PrintStatus();
 419   mgr->StartAnalysis("local",chain);
 420 }
 421
 422 //_________________________________________________//
 423 void runProof(const char* mode = "ESD",
 424               const char* analysisType = 0x0,
 425               const char* pidMode = 0x0,
 426               Int_t stats = 0,
 427               const char* dataset = 0x0) {
 428   TString outputFilename1 = "Protons.QA."; outputFilename1 += analysisType;
 429   outputFilename1 += "."; outputFilename1 += pidMode;
 430   outputFilename1 += ".root"; //main QA file
 431   TString outputFilename2 = "Protons.MC.QA."; outputFilename2 += analysisType;
 432   outputFilename2 += "."; outputFilename2 += pidMode;
 433   outputFilename2 += ".root"; //MC process QA
 434   TString outputFilename3 = "Protons.QA.Histograms.";
 435   outputFilename3 += analysisType;
 436   outputFilename3 += "."; outputFilename3 += pidMode;
 437   outputFilename3 += ".root"; //Accepted cut distributions
 438   TString outputFilename4 = "Protons.Efficiency.";
 439   outputFilename4 += analysisType;
 440   outputFilename4 += "."; outputFilename4 += pidMode;
 441   outputFilename4 += ".root"; //Reco and PID efficiency
 442   TString outputFilename5 = "Vertex.QA.root"; //vertex QA
 443
 444   gEnv->SetValue("XSec.GSI.DelegProxy","2");
 445   printf("****** Connect to PROOF *******\n");
 446   TProof::Open("alicecaf.cern.ch");
 447   gProof->SetParallel();
 448
 449   // Enable the Analysis Package
 450   gProof->UploadPackage("STEERBase.par");
 451   gProof->EnablePackage("STEERBase");
 452   gProof->UploadPackage("ESD.par");
 453   gProof->EnablePackage("ESD");
 454   gProof->UploadPackage("AOD.par");
 455   gProof->EnablePackage("AOD");
 456   gProof->UploadPackage("ANALYSIS.par");
 457   gProof->EnablePackage("ANALYSIS");
 458   gProof->UploadPackage("ANALYSISalice.par");
 459   gProof->EnablePackage("ANALYSISalice");
 460   gProof->UploadPackage("CORRFW.par");
 461   gProof->EnablePackage("CORRFW");
 462   gProof->UploadPackage("PWG2spectra.par");
 463   gProof->EnablePackage("PWG2spectra");
 464
 465   //____________________________________________//
 466   //gProof->Load("configProtonAnalysis.C");
 467   gROOT->LoadMacro("configProtonAnalysis.C");
 468   AliProtonQAAnalysis *analysis = GetProtonQAAnalysisObject(mode,
 469                                                             analysisType,
 470                                                             pidMode);
 471   //____________________________________________//
 472   // Make the analysis manager
 473   AliAnalysisManager *mgr = new AliAnalysisManager("protonAnalysisQAManager");
 474   AliVEventHandler* esdH = new AliESDInputHandler;
 475   mgr->SetInputEventHandler(esdH);
 476   AliMCEventHandler *mc = new AliMCEventHandler();
 477   mgr->SetMCtruthEventHandler(mc);
 478
 479   //____________________________________________//
 480   // 1st Proton task
 481   AliAnalysisTaskProtonsQA *taskProtonsQA = new AliAnalysisTaskProtonsQA("TaskProtonsQA");
 482   taskProtonsQA->SetAnalysisObject(analysis);
 483   mgr->AddTask(taskProtonsQA);
 484
 485   // Create containers for input/output
 486   /*AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("dataChain",
 487                                                            TChain::Class(),
 488                                                            AliAnalysisManager::kInputContainer);*/
 489   AliAnalysisDataContainer *cinput1  = mgr->GetCommonInputContainer();
 490   AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("globalQAList",
 491                                                             TList::Class(),
 492                                                             AliAnalysisManager::kOutputContainer,
 493                                                             outputFilename1.Data());
 494   AliAnalysisDataContainer *coutput2 = mgr->CreateContainer("pdgCodeList",
 495                                                             TList::Class(),
 496                                                             AliAnalysisManager::kOutputContainer,
 497                                                             outputFilename2.Data());
 498   AliAnalysisDataContainer *coutput3 = mgr->CreateContainer("mcProcessList",
 499                                                             TList::Class(),
 500                                                             AliAnalysisManager::kOutputContainer,
 501                                                             outputFilename2.Data());
 502   AliAnalysisDataContainer *coutput4 = mgr->CreateContainer("acceptedCutList",
 503                                                             TList::Class(),
 504                                                             AliAnalysisManager::kOutputContainer,
 505                                                             outputFilename3.Data());
 506   AliAnalysisDataContainer *coutput5 = mgr->CreateContainer("rejectedCutList",
 507                                                             TList::Class(),
 508                                                             AliAnalysisManager::kOutputContainer,
 509                                                             outputFilename3.Data());
 510   AliAnalysisDataContainer *coutput6 = mgr->CreateContainer("acceptedDCAList",
 511                                                             TList::Class(),
 512                                                             AliAnalysisManager::kOutputContainer,
 513                                                             outputFilename3.Data());
 514   AliAnalysisDataContainer *coutput7 = mgr->CreateContainer("efficiencyList",
 515                                                             TList::Class(),
 516                                                             AliAnalysisManager::kOutputContainer,
 517                                                             outputFilename4.Data());
 518   AliAnalysisDataContainer *coutput8 = mgr->CreateContainer("vertexList",
 519                                                             TList::Class(),
 520                                                             AliAnalysisManager::kOutputContainer,
 521                                                             outputFilename5.Data());
 522   AliAnalysisDataContainer *coutput9 = mgr->CreateContainer("cutEfficiencyList",
 523                                                             TList::Class(),
 524                                                             AliAnalysisManager::kOutputContainer,
 525                                                             outputFilename4.Data());
 526
 527   //____________________________________________//
 528   mgr->ConnectInput(taskProtonsQA,0,cinput1);
 529   mgr->ConnectOutput(taskProtonsQA,0,coutput1);
 530   mgr->ConnectOutput(taskProtonsQA,1,coutput2);
 531   mgr->ConnectOutput(taskProtonsQA,2,coutput3);
 532   mgr->ConnectOutput(taskProtonsQA,3,coutput4);
 533   mgr->ConnectOutput(taskProtonsQA,4,coutput5);
 534   mgr->ConnectOutput(taskProtonsQA,5,coutput6);
 535   mgr->ConnectOutput(taskProtonsQA,6,coutput7);
 536   mgr->ConnectOutput(taskProtonsQA,7,coutput8);
 537   mgr->ConnectOutput(taskProtonsQA,8,coutput9);
 538
 539   if (!mgr->InitAnalysis()) return;
 540   mgr->PrintStatus();
 541
 542   if(dataset)
 543     mgr->StartAnalysis("proof",dataset,stats);
 544   else {
 545     // You should get this macro and the txt file from:
 546     // http://aliceinfo.cern.ch/Offline/Analysis/CAF/
 547     gROOT->LoadMacro("CreateESDChain.C");
 548     TChain* chain = 0x0;
 549     chain = CreateESDChain("ESD82XX_30K.txt",stats);
 550     chain->SetBranchStatus("*Calo*",0);
 551
 552     mgr->StartAnalysis("proof",chain);
 553     //mgr->StartAnalysis("local",chain);
 554   }
 555 }
 556
 557 //_________________________________________________//
 558 Int_t setupPar(const char* pararchivename) {
 559   ///////////////////
 560   // Setup PAR File//
 561   ///////////////////
 562   if (pararchivename) {
 563     char processline[1024];
 564     sprintf(processline,".! tar xvzf %s.par",pararchivename);
 565     gROOT->ProcessLine(processline);
 566     const char* ocwd = gSystem->WorkingDirectory();
 567     gSystem->ChangeDirectory(pararchivename);
 568
 569     // check for BUILD.sh and execute
 570     if (!gSystem->AccessPathName("PROOF-INF/BUILD.sh")) {
 571       printf("*******************************\n");
 572       printf("*** Building PAR archive    ***\n");
 573       printf("*******************************\n");
 574
 575       if (gSystem->Exec("PROOF-INF/BUILD.sh")) {
 576         Error("runAnalysis","Cannot Build the PAR Archive! - Abort!");
 577         return -1;
 578       }
 579     }
 580     // check for SETUP.C and execute
 581     if (!gSystem->AccessPathName("PROOF-INF/SETUP.C")) {
 582       printf("*******************************\n");
 583       printf("*** Setup PAR archive       ***\n");
 584       printf("*******************************\n");
 585       gROOT->Macro("PROOF-INF/SETUP.C");
 586     }
 587
 588     gSystem->ChangeDirectory("../");
 589   }
 590   return 1;
 591 }