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