PWG2/runProtonAnalysis.C

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