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