PWGLF/SPECTRA/AntiprotonToProton/runProtonAnalysis.C

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