PWGLF/SPECTRA/AntiprotonToProton/runProtonAnalysisQA.C

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